Appartus for providing application services, method thereof, and computationally-implementable storage medium for storing a program for providing application services

Abstract

One embodiment of the present invention provides a method for providing an application service, comprising the steps of: a processor of a virtualized computing system within a platform providing an isolated workspace receiving scrap adapter configuration information from a client using said workspace; collecting data of a partner set by said client based on said scrap adapter configuration information; and storing said collected data in an inbox slot of a message box within said platform.

Description

Technology Field

[0001] The following disclosure relates to an application service providing device, an application service providing method, and a storage medium storing a program executable by a computer that provides an application service. Background Technology

[0003] In accordance with transactions between companies or between a company and an individual, the exchange of transaction-related information or documents containing such information is taking place.

[0004] However, since the exchange of documents and the format or specifications of the information to be included in them can vary depending on the company, and because document formats, internal requests, or recording methods differ according to various types of transactions, various software has been developed.

[0005] Such software can assist in entering and exchanging information necessary for transactions between various companies using standardized forms, such as electronic document exchange. As this method of electronic document exchange becomes generalized and standardized procedures are established, converting data into standardized electronic documents and exchanging, storing, and processing them on the computers of the trading parties can save time and effort.

[0006] However, even software for generating such standardized electronic documents often had the inconvenience of requiring individual modifications depending on the parties to the transaction, the nature of the transaction, and the format and content of the transaction.

[0007] New entrants to the market may find it difficult to prepare in the standardized forms and formats required by existing trading partners. Due to the complex nature of transactions and numerous requirements within the market, there are instances where it is challenging to understand or adhere to these standardized transaction formats, which can hinder the activation of trade.

[0008] In addition, when the parties to a transaction use software that is not compatible with each other or have separate software on systems that are not compatible with each other, there were technical inconveniences such as having to develop software for the transaction or having to provide software that fits the system.

[0009] And even if application services were provided using the same software image, there were difficulties in providing efficient services, such as the need to prepare and provide software packages of all versions and types for each client.

[0010] In particular, there is a need for the entire system to continue operating without interruption even if problems occur with the servers or computing resources used by the transaction parties, and for the system to be able to flexibly respond to increases in the number of users or the volume of data. The problem to be solved

[0012] The disclosed embodiment is intended to solve the above-mentioned inconvenient problems and may provide an application service providing device, an application service providing method, and a storage medium for storing a computer-executable program for providing application services, in order to support uninterrupted scale-out through distributed package replication and distributed channel communication. means of solving the problem

[0014] One embodiment of the present invention provides a method for providing an application service, comprising the steps of: a processor of a virtualized computing system within a platform providing an isolated workspace receiving scrap adapter configuration information from a client using said workspace; collecting data of a partner set by said client based on said scrap adapter configuration information; and storing said collected data in an inbox slot of a message box within said platform.

[0015] The above application service provision method includes the step of the platform providing an Application Programming Interface (API) necessary for the scrap adapter to use the framework, wherein the API includes at least one of a Configuration Service Interface providing access to configuration settings, a Task Service Interface providing functions related to task processing, a Channel Access Service Interface providing access to a communication channel, a Message Box Access Service Interface providing access to a message box, and a configuration repository Service Interface.

[0016] One embodiment of the present invention provides an application service providing device comprising a storage medium for storing data; and a processor providing an isolated workspace for processing said data, wherein the processor receives scrap adapter setting information from a client using said workspace, collects data of a partner set by said client based on said scrap adapter setting information, and stores said collected data in an inbox slot of a message box within said platform.

[0017] The above platform provides an Application Programming Interface (API) necessary for the scrap adapter to use the framework, and the API is characterized by including at least one of a Configuration Service Interface that provides access to configuration settings, a Task Service Interface that provides functions related to task processing, a Channel Access Service Interface that provides access to a communication channel, a Message Box Access Service Interface that provides access to a message box, and a Configuration Storage Service Interface.

[0018] One embodiment of the present invention provides a computer-readable recording medium storing an application service provider program, wherein a processor of a virtualized computing system within a platform providing an isolated workspace receives scrap adapter configuration information from a client using said workspace; collects data of a partner configured by said client based on said scrap adapter configuration information; and stores said collected data in an in-box slot of a message box within said platform. Effects of the invention

[0020] According to the disclosed embodiment, technical inconveniences for transactions can be resolved and transactions can be further activated.

[0021] According to the disclosed embodiments, even if standardized forms for existing transactions are not prepared or there are complex transaction requirements, market transactions can be technically activated using software.

[0022] According to the disclosed embodiment, a convenient transaction system can be provided even if the transaction parties use software that is not compatible with each other or have separate software in systems that are not compatible with each other.

[0023] According to the disclosed embodiment, there is an advantage that a mapping program can be defined relatively easily even if the user is not familiar with development scripts.

[0024] According to the disclosed embodiment, developers can easily implement and manage complex mapping logic through a user-friendly interface and a visual programming method.

[0025] According to the disclosed embodiment, by distributing a software package across multiple worker nodes (physical servers), the actual service can be performed without interruption even if a failure occurs in one worker node. Brief explanation of the drawing

[0027] FIG. 1 is a flowchart disclosing an example of a method for providing an application service according to an embodiment. FIG. 2 is a drawing disclosing an example of providing application services to a client through a workspace among the disclosed embodiments. FIG. 3 is a conceptual diagram disclosing layer-by-layer elements for the provision of application services according to an embodiment. FIG. 4 is a drawing disclosing a specific example in which an application service providing device according to an embodiment establishes a channel between an instance and a client or partner. FIG. 5 is a drawing disclosing an example of setting up a distributed channel and receiving a service according to an embodiment. FIG. 6 is a drawing disclosing an example of managing configuration information of a package installed according to an embodiment. FIG. 7 is a drawing illustrating an example of managing and using a package according to the workspace of the disclosed embodiment. FIG. 8 is a drawing disclosing an example of mapping EDI information as a type of application service according to an embodiment. FIG. 9 is a drawing disclosing an example of providing an application service using an integrated package according to an embodiment. FIG. 10 is a drawing illustrating an example of an interface of a platform according to an example of providing a disclosed application service. FIG. 11 is a drawing illustrating another example of an interface of a platform according to an example of providing a disclosed application service. FIG. 12 is a drawing disclosing an example in which an application service providing device according to an embodiment provides a framework capable of integrating different systems. FIG. 13 is a diagram illustrating an example of graphically coding connectors and services among the integration flow functions when developing an integration flow based on an embodiment. FIG. 14 is a diagram illustrating an example of graphically coding the processor, control flow, and modifier among the integration flow functions when developing an integration flow based on an embodiment. FIG. 15 is a drawing illustrating the interface of an agent when the agent provided by the platform of an instance system according to an embodiment is executed. FIG. 16 is a drawing illustrating an example of an interface of an agent adapter provided by the platform of an instance system according to an embodiment. FIG. 17 is a drawing illustrating another example of an interface of an agent adapter provided by the platform of an instance system according to an embodiment. FIG. 18 is a drawing showing an example of an agent adapter of a platform of an instance system according to an embodiment establishing a transmit / receive channel. FIG. 19 is a drawing disclosing an example of transmitting EDI data, which is transaction information, using a platform of an instance system according to an embodiment. FIG. 20 is a drawing disclosing an embodiment of running an adapter in a workspace according to an embodiment. FIG. 21 is a drawing disclosing an example of an adapter package. FIG. 22 is a drawing disclosing an example in which an adapter according to an embodiment uses a framework. FIG. 23 is a drawing disclosing an example of a service provided by an adapter package according to an embodiment. FIG. 24 is a drawing disclosing an example of an adapter developed in a workspace according to an embodiment. FIG. 25 is a drawing disclosing an example in which an application service providing device according to an embodiment converts a data format. FIG. 26 is a drawing disclosing an example in which an application service providing device according to an embodiment converts a data format using a schema and a mapping script. FIG. 27 is a drawing disclosing an example of deserialization and serialization based on a schema according to an embodiment. FIG. 28 is a drawing disclosing an example of a mapping script according to an embodiment. FIG. 29 is a drawing disclosing an example of providing a user interface for developing a mapping flow among the disclosed embodiments. FIG. 30 is a drawing disclosing an example of providing a user interface for developing a mapping flow among the disclosed embodiments. FIG. 31 is a drawing disclosing an example of providing a user interface for developing a mapping flow among the disclosed embodiments. FIG. 32 is a drawing disclosing an example of providing a user interface for developing a mapping flow among the disclosed embodiments. FIG. 33 is a drawing disclosing an example of providing a user interface for developing a mapping flow among the disclosed embodiments. FIG. 34 is a drawing disclosing an example of providing a user interface for developing a mapping flow among the disclosed embodiments. FIG. 35 is a drawing disclosing an example in which an application service providing device according to an embodiment generates and tests an integrated package. FIG. 36 is a drawing disclosing an example of providing a user interface for developing an integrated flow according to an embodiment. FIG. 37 is a drawing disclosing an example of providing a user interface for developing an integrated flow that performs mapping according to an embodiment. FIG. 38 is a drawing disclosing an example of providing a web EDI service using a message box according to an embodiment. FIG. 39 is a drawing disclosing an example of providing a web EDI service using a message box according to an embodiment. FIG. 40 is a drawing illustrating an example of an interface of a platform according to an embodiment. FIG. 41 is a drawing illustrating an example of a user interface of a web EDI service according to an embodiment. FIG. 42 is a drawing illustrating an example of a user interface of an inbox document service according to an embodiment. FIG. 43 is a drawing illustrating another example of a user interface of an inbox document service according to an embodiment. FIG. 44 is a drawing illustrating an example of a user interface of a draft document service according to an embodiment. FIG. 45 is a drawing illustrating an example of a user interface of a draft document service according to an embodiment. FIG. 46 is a drawing illustrating an example of a user interface of a draft document according to an embodiment. FIG. 47 is a drawing illustrating an example of a user interface of a cent document according to an embodiment. FIG. 48 is a flowchart illustrating an application service provision method for providing a web EDI service according to an embodiment. FIG. 49 is a drawing showing the operation of a scrap adapter according to an embodiment. FIG. 50 is a drawing illustrating an example of a user utilizing a scrap adapter according to an embodiment. FIG. 51 is a drawing illustrating an example of a user interface of a platform according to an embodiment. FIG. 52 is a drawing illustrating an example of a user interface of a platform according to an embodiment. FIG. 53 is a drawing disclosing a data collection method according to another embodiment. FIG. 54 is a drawing showing the operation of a scrap adapter according to an embodiment. Specific details for implementing the invention

[0028] The following discloses embodiments that can resolve the above-mentioned problems and technical inconveniences for transactions.

[0029] When referring to the components of the embodiments below, they can all be implemented using optimized hardware or software, unless specifically limited to physical devices.

[0031] FIG. 1 is a flowchart disclosing an example of a method for providing application services according to an embodiment.

[0032] The application service provision method according to the disclosed embodiment allows multiple clients to obtain, download, or add or change desired functions for transactions through the platform.

[0033] The embodiment can receive a channel request to transmit and receive information from a client using a virtual isolated workspace (S100).

[0034] When a client connects to the platform, the system can provide the client with a virtual, isolated workspace.

[0035] Clients may have separate workspaces for receiving services, but the hardware foundation of the systems providing each workspace may be common.

[0036] A system administrator or client may perform remote control and updates of the system so that the client can receive such services, and the system may be equipped with communication functions according to protocols associated with various standards.

[0037] The client can request a channel from the platform to send and receive desired information, and the platform can allow the client to establish the channel.

[0038] Detailed examples of this are disclosed below.

[0039] An embodiment may provide a platform service that allows a client to create, modify, or save application packages, etc., in their workspace (S200).

[0040] The client may develop an application package or a part of a package in a system such as the embodiment, trade related applications or software, and operate a business related to the transaction.

[0041] In the following, the terms "application package" or "package" refer to a bundle of programs or files, including adapter packages that support protocols or services, resource packages necessary for program execution, and integrated packages in which various packages are combined. In the following examples, an application package may also be referred to as a software package depending on the case.

[0042] The system can provide various means or specialized computer languages ​​that support mapping to various data formats and structures desired by the client. It can also provide applications and related tools to enable the client to modify application packages.

[0043] Detailed examples of this are disclosed below.

[0044] The embodiment may provide a service that controls the scale-out of a service when the client uses an application package or when another client receives the application service in their workspace (S300). This step may proceed with scale control related to service provision as needed. Depending on the provided system, the client may receive the application service without interruption or operate the application service.

[0045] Detailed examples of this are disclosed below.

[0047] FIG. 2 is a diagram illustrating an example of providing application services to a client through a workspace among the disclosed embodiments.

[0048] This drawing is a conceptual diagram for explaining workspaces and multi-tenancy among embodiments providing the disclosed application services.

[0049] An embodiment may provide a Software-as-a-Service (hereinafter SaaS) to a user.

[0050] The embodiment may provide an application or SaaS-based software service used for transmitting and receiving information, such as transactions between the parties.

[0051] In this drawing, the parties to the transaction are represented as client 1 (110), client 2 (120), or client 3 (130).

[0052] Clients (110, 120, 130) can send and receive various information, including business transactions, with their respective partners. In this case, the clients (110, 120, 130) can use the example application service provision method.

[0053] An application service providing device according to an embodiment includes an instance system (1000) that provides an application including SaaS-type software, and a manager system (2000) that enables the provision of application services through the instance system (1000).

[0054] The manager system (2000) can provide scale-out instance systems (1000) to clients (110, 120, 130).

[0055] In the instance system (1000), the interface of the service provided by the manager system (2000) to the clients (110, 120, 130) can be executed.

[0056] The manager system (2000) may include a manager server (2100) that connects to and controls the instance system (1000), and a database (2200) capable of storing transmitted and received information and the requirements of clients (110, 120, 130). The functions of the manager system (2000) will be described in detail below.

[0057] The instance system (1000) provided by the manager system (2000) may include at least one node.

[0058] In the example of this drawing, Node #0 (1100) can act as a service coordinator that provides application services and performs scale-out under the control of the manager system (2000).

[0059] In this example, the coordinator (1100), which is node #0, can control the scale of the system by connecting to worker nodes such as the first node (Node #1), the second node (Node #2), the third node (Node #3), and the Nth node (Node #N).

[0060] For example, connections between nodes can utilize interface protocols such as the HTTP protocol of a RESTful Application Programming Interface (API) (hereinafter referred to as HTTP / REST), and a RESTful Application Programming Interface (API) can enable data to be transmitted and received between servers using HTTP.

[0061] For example, a coordinator (1100) that is Node #0 can send and receive data via HTTP / REST with each of the nodes of the first node (Node #1), the second node (Node #2), the third node (Node #3), to the Nth node (Node #N).

[0062] Likewise, the first node (Node #1) can send and receive data with other nodes (Node #0, the second node (Node #2), the third node (Node #3), and the Nth node (Node #N)) based on HTTP / REST.

[0063] A coordinator (1100) can install the software package on each node (in this example, from the first node (Node #1) to the Nth node (Node #N)) in response to a request for software package installation from the manager system (2000).

[0064] Each node may include a framework that allows the creation of workspaces regardless of the type of system. This will be discussed later.

[0065] The coordinator (1100) can provide workspaces (1510, 1520, 1530) running on the framework of each node to each client (110, 120, 130).

[0066] Clients (110, 120, 130) may have workspaces (1510, 1520, 1530) isolated from one another, and may receive, modify, or use applications or software packages through the isolated workspaces.

[0067] In this example, the first node (Node #1) can provide software package A and software package C, provided by the framework within the first node (Node #1), to the client through the coordinator (1100).

[0068] The second node (Node #2) can provide software package A and software package B, provided by the framework within the second node (Node #2), to the client through the coordinator (1100).

[0069] The third node (Node #3) can provide software package B and software package C, provided by the framework within the third node (Node #3), to the client through the coordinator (1100).

[0070] The manager system (2000) can reliably provide each workspace (1510, 1520, 1530) isolated from one another to clients (110, 120, 130) through the instance system (1000).

[0071] For example, client 1 (110) can use the workspace (1510) independently.

[0072] Client 1 (110) can send and receive necessary data in its workspace through a channel established with the coordinator (1100). For example, Client 1 (110) can receive necessary software packages A and C from the coordinator (1100) through an HTTP channel in workspace A (1510). Detailed examples of establishing a channel between the workspace and the coordinator (1100) or between the coordinator (1100) and each node will be described later.

[0073] Client 2 (120) can receive necessary software packages A and B from the coordinator (1100), for example, via an HTTP channel in workspace B (1520).

[0074] Likewise, client 3 (130) can receive the necessary software packages B and C from the coordinator (1100) via an HTTP channel in workspace C (1530).

[0075] The instance system (1000) can provide a virtualized system so that clients (110, 120, 130) do not need to know which node within the instance system (1000) provides the desired software package in their workspaces (1510, 1520, 1530).

[0076] Each node (Node #1, Node #2, Node #3, Node #N) that stores and provides software packages by a coordinator (1100) can store software packages that can be provided to workspaces (1510, 1520, 1530). That is, multiple nodes (Node #1, Node #2, Node #3, Node #N) can provide virtualized and isolated workspaces (1510, 1520, 1530).

[0077] Each node (Node #1, Node #2, Node #3, Node #N) includes a framework, and each framework can control the downloading and execution of software packages from a software package storage unit (not shown). This is explained in detail below.

[0078] Software packages required for workspace A (1510) used by client 1 (110) can be stored on at least one of the nodes (Node #1, Node #2, Node #3, Node #N).

[0079] In this example, software package A is stored in the first node (Node #1) and the second node (Node #2), but it may also be transferred to and stored in other nodes (Node #3, Node #N) by scaling out of the coordinator (1100).

[0080] Software package B is stored in the second node (Node #2) and the third node (Node #3), but it may also be transferred to and stored in other nodes (Node #1, Node #N) by scaling out of the coordinator (1100).

[0081] Similarly, software package C is stored in the third node (Node #3) and the first node (Node #1), but may also be transferred to and stored in other nodes (Node #2, Node #N) by scaling out the coordinator (1100).

[0082] In this way, software packages can be distributed and installed across multiple nodes. The coordinator (1100) can store information on which node a software package is installed on, perform routing for software package requests if necessary, and perform task scheduling functions for the nodes under management.

[0083] Therefore, clients (110, 120, 130) can obtain software packages in their respective virtualized and isolated workspaces (1510, 1520, 1530) without needing to know which node the desired software package is stored on due to the scale-out of the coordinator (1100).

[0084] The manager system (2000) can control the coordinator (1100) to provide application services so that clients (110, 120, 130) can obtain the software packages they want.

[0085] The nodes serve as worker nodes where the adapter package or software package described below is installed and executed. In the instance system (1000), the worker nodes can be scaled out automatically or manually under the management of the manager system (2000) if necessary.

[0087] FIG. 3 is a conceptual diagram disclosing layer-by-layer elements for providing application services according to an embodiment.

[0088] The application service providing device according to the embodiment can be controlled and managed by the manager system (2000).

[0089] The manager system (2000) can provide application services, such as EDI services, using an on-premises system or a cloud system. Detailed examples of how the manager system (2000) provides services are described below.

[0090] The computing system may include at least one of an on-premises system or a cloud system.

[0091] A computing system may include a virtualization layer, such as containers or virtual machines (VMs), that can virtualize computing resources.

[0092] This drawing illustrates a case where a virtualization layer is included, and the virtualization layer is indicated by a dotted line.

[0093] For example, computing systems can provide containers as a virtualization layer. Containers can use only as much of the host's resources as is necessary to run applications on top of the host operating system (OS). Using container images enables the rapid development and deployment of applications.

[0094] The computing system may include a framework layer (1700) that provides a framework. The framework may enable various applications to run through an application programming interface (API) (1610, 4100).

[0095] A workspace (1500, 3000) or an interface governance platform (4000) is located on an application programming interface (API) (1610) or a governance API (4100), respectively, and various applications can be run on the application programming interface (API) (1610, 4100).

[0096] The client (100) can receive application services, namely software packages, provided by the manager system (2000), from a system having layers such as those exemplified in this drawing.

[0097] For example, a client (100) can use services such as an EDI application (EDI App.) through an isolated workspace (1500). In this example, the client (100) can use applications or services such as EDI and other application services (App.), message services, web services, protocol adapter services, data transformation services, monitoring services, and security services through the workspace (1500). Applications or services on the workspace (1500) are disclosed in detail below.

[0098] The partner (200) may be an actual trading partner of the client (100) or another trading entity related to the transaction, and may use application services through the workspace (1500) or receive application services such as the EDI service provided by the client (100).

[0099] When a client (100) conducts a transaction through an application related to an EDI service, a partner (200) can conduct a transaction through an EDI service application provided by the client (100).

[0100] The manager system (2000) can provide an environment in which a client can develop applications necessary for their own transactions.

[0101] The manager system (2000) can develop and test applications in the development workspace (3000) and provide application services developed through the workspace (1500). In addition, the manager system (2000) manages the computing environment that provides the development workspace (3000) to a client (100) or partner (200), and enables the client (100) or partner (200) to develop necessary applications in the development workspace (3000).

[0102] This development workspace (3000) may include a development tool application for developing applications, a payment / billing application for determining the usage and billing system for developed applications, an app store for selling developed applications, and a back-office application that supports and controls these functions.

[0103] For example, a client (100) or a partner (200) can develop, modify, and test applications through a development workspace (3000). The client (100) or a partner (200) can develop applications or software packages themselves in the development workspace (3000), as well as applications provided by the manager system (2000).

[0104] Additionally, the client (100) may provide the application developed through the development workspace (3000) to other clients or partners through the app store (3000) illustrated in the drawing.

[0105] Partner (200) and manager system (2000) can also use the provided system to develop, test, utilize, and provide services for software packages, just like client (100).

[0106] The manager system (2000) may provide inspection, control, etc. of the client system through the interface governance platform (4000) on the solution API (4100), and such services will be disclosed separately in detail.

[0107] Below, detailed examples are first described of how a client (100) receives or provides services using a software package through a workspace (1500).

[0109] FIG. 4 is a diagram disclosing a specific example of an application service providing device according to an embodiment establishing a channel between an instance and a client or partner.

[0110] According to the concept disclosed above, the application service manager (2100) may enable a client or partner (300) to provide, use, or modify an application through the instance system (1000). The instance system (1000) may include a coordinator (1100) and an Nth node (1300), which is any node.

[0111] The application service manager (2100) can distribute information for installing an agent (350) to a client / partner (300). For example, the information for installing the agent (350) may include agent configuration information, key information for agent configuration, resource management information, user management configuration information, etc.

[0112] For example, agent configuration information may include information such as the time for synchronizing channel information, a timeout for HTTP requests, the key value of a session key associated with the installed browser, and the path required for the agent to send and receive related information.

[0113] A channel is configured to use a service provided by an application service manager (2100) and can be described as a component for connecting with a package, such as an adapter package. An example related to this is described in detail below.

[0114] An agent (350) may be installed on the client / partner (300), and the agent (350) may collect resource management information, connection information, user information, etc. of the client / partner (300). If necessary, the agent (350) may access the database or file system of the client / partner (300).

[0115] The agent (350) may request a software package from the coordinator (1100) of the instance system (1000). In this case, the agent (350) may request a channel service to receive the software package from the agent adapter (1350) of the coordinator (1100). Here, an HTTP request may be used for the channel service that the agent (350) requests from the agent adapter (1350).

[0116] For example, when an agent (350) of a client / partner (300) forwards a request to a preset HTTP URI, the coordinator (1100) may allow HTTP traffic coming into a specific port, i.e., an inbound HTTP connection, and convert this HTTP service into a channel service that forwards it to the agent adapter (1350) of the Nth node (1300), which is a worker node.

[0117] The information for installing the agent (350) already includes path information for connecting to the instance system (1000).

[0118] When an agent (350) is installed on a client / partner (300), the administrator of the client / partner (300) can set management information, user information, etc. of the client / partner (300) system managed by the agent (350), and can also set the synchronization time with the agent adapter (1350) of the Nth node (1300).

[0119] The application service manager (2100) can set configuration information for an agent adapter (1350) installed in the instance system (1000) in relation to the registered agent (350), and information on whether synchronization is active with the registered agent (350).

[0120] The application service manager (2100) can set outbox slot information within a message box for storing information transmitted by the registered agent (350) and inbox slot information within a message box for storing information received by the registered agent (350).

[0121] The application service manager (2100) stores the information transmitted by the agent (350) and the information received by the agent (350) in the outbox slot and inbox slot within the message box (2110), respectively, according to the information set as above. The slot within the message box is a logical separation concept for storing data processing units, and the message box can store and output data processing units like a queue.

[0122] Meanwhile, the application service manager (2100) can also set authentication key information that allows the registered agent (350) and agent adapter (1350) to perform authentication.

[0123] In this way, when the agent (350) is registered with the client / partner (300) and the agent adapter (1350) is configured on the instance system (1000), the agent adapter (1350) can be connected to the resources configured on the agent (350).

[0124] And, according to the information set by the agent (350), related information or data can be transmitted and received with the agent adapter (1350).

[0125] In this drawing, the channel through which the agent (350) transmits information (outbox) output from the client / partner (300) resources according to a set period is indicated as the send channel. And the channel through which the agent (350) receives information (inbox) transmitted from the agent adapter (1350) is indicated as the receive / polling channel.

[0126] The agent (350) can send and receive requested data from the agent adapter (1350) through the configured send channel and the configured receive / polling channel.

[0128] FIG. 5 is a diagram disclosing an example of managing a channel and receiving services in a distributed system according to an embodiment.

[0129] As illustrated, nodes within the instance system (1000) can transmit and receive data through channels to provide services. A channel is a general term for a passage that calls data or packages to provide services, or searches to find out which node an already registered channel is running on.

[0130] Here, an example is disclosed in which a coordinator (1100) of an instance system (1000) manages packages installed on nodes of a distributed environment through a channel connection.

[0131] The coordinator (1100) can store channel information that can connect each worker node and information about packages stored in each worker node.

[0132] For example, the coordinator (1100) can register and store information about packages stored in the worker nodes (1110, 1120). The coordinator (1100) can register and store information about adapter package A and integration package stored by the worker node (1110) of the first node (Node #1), and register and store information about adapter package B stored by the worker node (1120) of the second node (Node #2).

[0133] The coordinator (1100) may receive a service request related to a package from a client or partner. As disclosed above, the case in which the service request is received via an HTTP request containing URL information is exemplified here.

[0134] The coordinator (1100) can set up a service channel for worker nodes if they are registered and mapped to the coordinator (1100) based on URL information included in the HTTP request.

[0135] As in the example here, the coordinator (1100) establishes an HTTP service channel in response to an HTTP request containing URL information of a client or partner. The coordinator (1100) can call adapter package A provided by the first worker node (worker node #1) (1110) through the established HTTP service channel.

[0136] Since the client or partner uses an isolated workspace provided by the coordinator (1100), the clients (or partners) may have different versions of packages within their respective workspaces and may use different versions of adapter packages.

[0138] Adapter package A requested by the client can be called via an HTTP service channel from the first worker node (worker node #1) (1110) according to the information registered in the coordinator (1100).

[0139] The first worker node (worker node #1) (1110) can provide adapter package A registered according to the HTTP service channel.

[0140] If a client or partner develops an application package in that workspace, an integration package including Adapter Package B may be required.

[0141] The coordinator (1100) knows that, according to the registered information, the first worker node (worker node #1) (1110) has stored the integration package and the second worker node (worker node #2) (1110) has stored the adapter package B.

[0142] The coordinator (1100) can search for an integrated package containing adapter package B from the first worker node (worker node #1) (1110) through an adapter function channel. And if adapter package B is not included in the integrated package stored in the first worker node (worker node #1) (1110), the first worker node (worker node #1) (1110) can call adapter package B stored in the second worker node (worker node #2) (1120) through a channel connection between the worker nodes.

[0143] Then, the second worker node (worker node #2) (1120) can provide the called adapter package B, in which case the coordinator (1100) can register the channel providing adapter package B to the adapter function channel so that adapter package B is provided together with the integration package.

[0144] In the embodiment disclosed as described above, various packages can be distributed and installed on multiple nodes. To communicate between packages or to call a specific adapter package from outside the instance system, the coordinator (1100) can manage and store channels for searching, calling, or registering the corresponding package on worker nodes capable of providing package services.

[0145] The agent adapter (1350) of the coordinate (1100) instance system (1000) can be configured for the sending and receiving channels from the agent (350) as exemplified. The agent adapter (1350) can configure a channel with a specific agent using channel-related information such as the agent's identifier and channel period.

[0146] In this way, the coordinator (1100) can manage various information so that requested package-related services can be distributed and performed on worker nodes. Although an HTTP service channel was exemplified above, packages may also be delivered via a file transfer channel such as FTP.

[0147] The coordinator (1100) may store adapter packages distributed across multiple worker nodes in shared memory (not shown) or storage.

[0148] In addition, the coordinator (1100) can also store and manage data such as logs related to adapters used by multiple clients.

[0150] FIG. 6 is a drawing that discloses an example of managing setting information of a package installed according to an embodiment.

[0151] In the example of this drawing, the coordinator (1100), the m-th node (node ​​#m) (3110), and the n-th node (node ​​#n) (3210), which are distributed systems within the instance system (1000), may each include configuration storage units (1115, 3115, 3215) within the node.

[0152] The application service manager (2100) of the manager system (2000) can store various configuration information (rectangles) related to a package. The stored configuration information may include various configuration information required when the package is executed on each node.

[0153] The application service manager (2100) can store configuration information of a package in a database (2200). The application service manager (2100) can obtain configuration information of a package from a specific node, in this example, the m-th node (node ​​#m) (3110), or store configuration information of a package requested from an external source in the database (2200).

[0154] The coordinator (1100) can store configuration information of a package managed by the application service manager (2100) in its configuration storage unit (1115). The application service manager (2100) can manage and store configuration information of the package through a control screen, etc.

[0155] The m-th node (node ​​#m) (3110) and n-th node (node ​​#n) (3210), which are wicker nodes within the instance system (1000), can receive configuration information of a related package from the configuration storage unit (1115) of the coordinator (1100) and store it in their respective configuration storage units (3115, 3215).

[0156] In this example, the nth node (node ​​#n) (3210), which is a worker node, can synchronize the configuration information of a package with the configuration information of the package stored in the configuration storage unit (1115) of the coordinator (1100). This synchronization may be performed periodically, or may be synchronized at different intervals depending on the configuration.

[0157] When the nth node (node ​​#n) (3210), which is a worker node, needs to execute a package, it can execute the package using the configuration information synchronized and stored in its configuration storage unit (3215).

[0158] The client / partner can change and save the package configuration information of the m node (node ​​#m) (3110), which is a worker node, through the package configuration screen of the coordinator (1100), etc.

[0159] If the package configuration information of the m node (node ​​#m) (3110), which is a worker node, is changed, the changed configuration information of the package can be transmitted to the application service manager (2100).

[0160] Again, the application service manager (2100) can store the changed configuration information of the package transmitted from the m node (node ​​#m) (3110) in the database (2200).

[0162] FIG. 7 is a drawing that discloses an example of managing and using a package according to the workspace of the disclosed embodiment.

[0163] Clients can create, run, and modify various packages in an isolated workspace.

[0164] For example, a client can run an adapter package in a workspace, and the adapter package can be executed using configuration information stored in the configuration store. However, in some cases, the package may be executed by referring to resource files in addition to the configuration information in the configuration store.

[0165] Resource files can be installed in a workspace as mapping programs, which are a type of resource package. Resource files can be accessed using resource paths when a package, such as an adapter package, is executed, allowing the adapter package to run.

[0166] According to the disclosed embodiments, both development or testing and operation of a package are possible in the workspace.

[0167] Accordingly, according to the embodiment, resource files can be provided by separating the workspace for operation and the workspace for development.

[0168] In the example of this drawing, when developing an adapter package in a workspace (1510) for development, the adapter package can be used as a program that can read and write resource files. In this case, the resource file, which is a mapping program, can be accessed by being designated as a writable shared resource path.

[0169] On the other hand, when running an adapter package in a workspace (1520) for operation, the resource file may be provided as a resource package that the adapter package can only read and cannot write to. In this case, the adapter package can install and access the resource package by referencing it, and cannot change the resource file within the resource package.

[0171] FIG. 8 is a diagram disclosing an example of mapping EDI information as a type of application service according to an embodiment.

[0172] The disclosed embodiments can not only provide various application services but also provide a platform environment for developing various application services.

[0173] In the following, an EDI service is described as an example of such an application service. As will be understood by those skilled in the art from the outset of the disclosure, various application services can be developed or provided using the embodiments, so it is not necessarily limited to an EDI service.

[0174] As a type of application service, EDI requires various types of transactions, parties, and transaction forms depending on the industry. Therefore, utilizing the disclosed embodiments for the complex and diverse transaction modes specific to each industry enables efficient transactions, making it highly effective for stimulating industrial transactions.

[0175] This diagram illustrates an application service that converts various information or documents required for EDI services between trading parties.

[0176] EDI comes in a wide variety of formats depending on the industry and specific rules and regulations, and transactions can only be established by creating and processing EDI documents according to these formats. EDI services exist in formats for various industries, including not only e-commerce but also transportation, logistics, finance, and insurance. EDI is standardized by international standardization organizations such as ISO, and is regulated and managed by UN / EDIFACT (United Nations / Electronic Data Interchange for Administration, Commerce and Transport) or ANSI (American National Standards Institute) X.12.

[0177] Depending on the characteristics of the transaction involving ordering and supply, different forms of documents containing different data or information may be used, and the systems used by the parties to the transaction may also differ.

[0178] For EDI services, documents between the two transaction parties must be mapped.

[0179] The example in this drawing conceptually discloses an advanced mapping engine, which is a program that converts documents containing data into a general-purpose system to provide EDI services.

[0180] For example, a transaction party may provide the EDI documents and EDI schema required for the transaction. This data can be converted into unmarshal data by decoding the bytes or strings contained in the EDI data (i.e., EDI documents) according to the input schema.

[0181] The mapping engine may include reference information that maps schemas to each other based on the schemas of the data to be transformed and the data to be transformed. Here, this mapping reference information is referred to as a mapping script.

[0182] Mapping reference information is intended to convert unmarshalled data into a target document of a different format and can have a script format.

[0183] The mapping engine can convert EDI data and decoded EDI schema data (unmarshal data) into a file of a specific format that can be used as an interface for general documents (here, a JSON file is an example) and a schema for said specific format file (here, a JSON schema is an example).

[0184] More specifically, as an EDI schema, the EDI format of the SEF (Standard Exchange Format) standard or EDI formats such as EXF (EDI Exchange Format) can be used.

[0185] The changed file format can be a flat file, JSON, XML, or other formats.

[0186] By performing marshalling or unmarshalling for each file type on files of a changed format, they can be converted into schema files defined by annotations. In other words, a result obtained by marshalling or unmarshalling can be obtained in a schema defined by the type corresponding to the data to be converted and the annotations corresponding to specific data types.

[0187] An embodiment can provide a user with a graphical interface that can generate a schema through this mapping engine and create a mapping script, which is mapping reference information.

[0189] FIG. 9 is a drawing disclosing an example of providing application services using an integrated package according to an embodiment.

[0190] According to an embodiment, the client (310) can provide an application service such as the disclosed example to a desired partner (320). The embodiment not only allows the client (310) to simply provide the service, but also enables the client (310) to directly provide a customized service to the desired partner (320) using the embodiment.

[0191] Here, an EDI service among application services is described as an example. In order for a client (310) to conduct a transaction with a partner (320), the embodiment may provide a coordinator (1100) and a worker node (1300) included in the instance system.

[0192] The application service manager (2100) can provide and manage an instance system so that the client (310) and the partner (320) can exchange information necessary for a transaction through the instance system.

[0193] As disclosed, an agent (not shown) is installed on the client (310), and the client can request EDI information, which is information necessary for a transaction, through the agent. In this case, the request for EDI information can be transmitted via HTTP traffic.

[0194] The coordinator (1100) of the instance system maps an HTTP request containing EDI information transmitted from a client (310) to a specified channel and forwards it to the corresponding worker node. In the example above, the coordinator (1100) disclosed an example of querying and managing the registration of a channel with an HTTP request containing URL information. The coordinator (1100) changes the HTTP request into a channel service and forwards it to the agent adapter (1350) of the corresponding worker node (1300) capable of receiving the channel service.

[0195] The agent adapter (1350) transmits the requested EDI information via the channel service to the message box (2110) of the application service manager (2100).

[0196] The message box (2110) of the application service manager (2100) can store EDI information transmitted from the agent adapter (1350) in the client inbox (2111).

[0197] The message box (2110) of the application service manager (2100) transmits the requested EDI information to the integration package (1380) of the worker node (1300).

[0198] Here, the integration package (1380) is a bundle of programs in which development items are integrated, including various development flows, Java or script programs. The integration package (1380) allows these development items to be used in combination and can address integrated requirements.

[0199] The integration package (1380) can enable the client (310) and the partner (320) to implement various requirements for trading by exchanging information with the message box (2110), the adapters (1350, 1370, 1390) of the worker nodes, and the channel service of the coordinator.

[0200] The integration package (1380) can create and register routing for necessary information exchange within the package when a specific channel is called according to the distributed channel service, thereby solving the user's requirements.

[0201] The elements and examples of use for the integration package (1380) are disclosed in detail below.

[0202] The integration package (1380) can transmit EDI information stored in the client inbox (2111) of the message box (2110) to the mapping adapter (1370).

[0203] The mapping adapter (1370) unmarshalls the EDI information of the client (310) received from the integration package (1380) and outputs it as EDI conversion data mapped to the information required by the partner (320).

[0204] When the integration package (1380) receives the EDI conversion data output by the mapping adapter (1370), it can transmit and store it in the partner outbox (2113) of the message box (2110) and then transmit it to the EDI adapter (1390).

[0205] The EDI adapter (1390) can convert EDI conversion data output from the integration package (1380) or stored in the partner outbox (2113) into a standardized format, such as UN / EDIFACT or ANSXI X.12.

[0206] The EDI adapter (1390) may also transmit and store standardized EDI conversion data in the partner outbox (2113) of the message box (2110).

[0207] The coordinator (1100) can receive standardized EDI conversion data stored in the partner outbox (2113) of the message box (2110) or converted by the EDI adapter (1390) through a channel service and convert it into HTTP traffic and transmit it to the partner (320).

[0208] As a result, the partner (320) can receive standardized EDI converted data from the EDI information transmitted by the client (310). Even when the partner (320) transmits its own EDI information to the client (310), data can be transmitted according to a similar process.

[0209] Accordingly, the client (310) and the partner (320) can easily use application services such as EDI services according to the disclosed embodiment, and can easily proceed with transactions according to the standardized format even if they do not know the standardized format or do not accurately understand the documents and information requested by the counterparty.

[0210] A client (310) or partner (320) can develop or use various software packages in their workspace and can also link them to an integrated package (1380).

[0211] The embodiment can provide the development of such a package and connection with existing packages through a very easy interface, and the developed package can also be sold, shared, or provided separately.

[0213] FIG. 10 is a drawing illustrating an example of an interface of a platform according to an example of providing a disclosed application service.

[0214] This diagram illustrates the interface provided by the platform when a user accesses the platform according to an example of providing application services.

[0215] When a client accesses a system initiated by the client, the platform may provide a user interface menu related to a user-specific workspace.

[0216] The client can access the instance system by using the interface platform provided by the manager system, as exemplified in this drawing, or by using HTTP including a URL, etc.

[0217] In the example of this drawing, the interface platform provided by the manager system may provide options for a user-only workspace (151), a message box (152), a file transfer (153), a message (SMS) sent to a mobile terminal (154), and information (155) for the corresponding standard mapping if the information exchange is related to EDI.

[0218] The workspace (151) is a menu that allows the client to use their own workspace, and the message box (152) stores messages related to the client.

[0219] File transfer (153) can check the file transfer method or history of files sent and received through the instance system.

[0220] The user can check the packages (161) they have used or developed, or the packages (162) they have purchased, etc., by selecting the user interface menu.

[0222] FIG. 11 is a drawing illustrating another example of an interface of a platform according to an example of providing a disclosed application service.

[0223] This diagram illustrates a user interface menu that can be seen when a client accesses a platform according to an example providing an application service initiated by the client and selects their workspace.

[0224] The client can check and use the workspace (171) created by the client, the instance system (172) associated with the workspace, the creation date (173) for each workspace, the description information (174) of the workspace, whether the workspace is active (175), the services (176) and packages (177) associated with the workspace, etc.

[0226] In the following, an embodiment is disclosed that can provide an application capable of interoperability with different systems when the application is an application that connects different systems. Software or applications developed through the workspace of the embodiment can be shared and used by multiple clients. If the systems used by the client or partner are different, the application developed by the client (or partner) must be available for use on the partner's (or client's) system.

[0227] An instance system according to an embodiment may provide a framework capable of integrating these different systems, and an embodiment thereof is disclosed as follows.

[0229] FIG. 12 is a drawing disclosing an example in which an application service providing device according to an embodiment provides a framework capable of integrating different systems.

[0230] The application service providing device according to the embodiment may include a framework that provides applications executable on different systems. Therefore, this integrated framework can provide applications that allow users of different systems to connect with each other, making it efficient and ideal for providing the EDI services exemplified above.

[0231] This drawing illustrates an integrated system architecture as a framework capable of integrating different systems. The integrated system architecture provided by the framework of the embodiment includes one or more route engines.

[0232] The route engine provides routes that connect endpoints, which are different systems, and processors, which are tasks performed between the endpoints.

[0233] Routes can describe the interface between systems, and in this example, the route engine disclosed an example of providing routes 1, 2, …, N.

[0234] A processor refers to the data processing that must be performed between transmitting and receiving systems, i.e., endpoints; in this example, a router processor and a message filter processor are used.

[0235] A component refers to an adapter of the transmitting and receiving systems to be integrated. In this example, the integrated system architecture discloses an example of connecting different systems by providing a unified interface to endpoints using components such as file, JMS, and HTTP.

[0236] Retrieving or receiving (or being called upon) data from a component is called a consumer, and calling, sending, or querying data from a component is called a producer.

[0237] A message is data exchanged for system communication, and a message may include a body, a header, and attachments.

[0238] An exchange is a container that holds messages exchanged between systems; it is an object created at the start of a route flow and its lifecycle is maintained only until the end of the flow.

[0239] Using such an integrated system architecture, applications that can be used on different systems can be created and developed into an integration package. As an example of this, an integration package (1380) was illustrated in the example above.

[0240] An integration package developed based on an integrated system architecture can provide an integration flow that can resolve integration requirements by linking with services or adapter packages provided by the platform according to the embodiment.

[0241] An integration package implements the necessary processes within the flow of the integrated system architecture and can provide scripts or Java programs capable of various data transformations.

[0242] The client (or partner) can generate integration packages necessary for providing their services by using the integrated system architecture exemplified above based on the platform according to the embodiment.

[0243] The platform according to the embodiment can also provide an environment in which a client (or partner) can very easily develop an integration package that implements an integration flow using graphic-based coding.

[0245] Below, an environment for developing an integration flow as an integration package provided by the integrated system architecture of the platform according to the embodiment is exemplified.

[0246] A platform according to an embodiment of a device providing application services can provide a graphic-based development environment using a library.

[0247] The client (or partner) can develop a graphic-based integration flow using the embodiment, and the integration flow may include five major functions.

[0248] Here, the five functions included in the integration flow are referred to as connector, service, processor, control flow, and modifier. These names are exemplary, and each function is described in detail as follows.

[0250] Figure 13 shows an example of graphically coding connectors and services among the integration flow functions when developing an integration flow based on an embodiment.

[0251] In this drawing (a), the connector may include a From graphic element indicating the start of a route of the integrated system architecture exemplified above.

[0252] A connector may include a To graphic element that defines external operations when a flow developed in a development environment is implemented, such as calling services or adapters or storing data.

[0253] As illustrated in this drawing, an integration flow can be developed using a connector that can represent the input / output (From / To) of a route as graphic coding in a graphic-based development environment provided by the embodiment.

[0254] To explain the connector in more detail, the connector can act as a consumer to call specific data (From Connector) and as a producer to provide data processed through the flow to the outside of the integration flow (To Connector).

[0255] A consumer may be a direct that calls a route within an application package when an integration flow calls specific data (From Connector), or a timer that periodically calls data by a task scheduler.

[0256] In addition, as another case where the integration flow calls specific data (From Connector), there may be a channel that registers a route as a channel and starts the route when the channel is called, a message box that periodically checks for unprocessed messages and starts the route if there are unprocessed messages, or an FTP that checks for documents in a registered FTP service path and starts the route if documents exist.

[0257] These consumers may include options such as a Route ID within the integrated package, an Auto Start indicating whether the route starts at the time of package installation, and a Start Order indicating the order in which the route starts when the package is installed.

[0258] A producer refers to the external output operation (To connector) of a connector as a result of executing an integration flow. Types of producers may include direct, which refers to calling another direct route within the same application package, and message box, which refers to saving a document to a message box. Additionally, producers may include channel, which refers to calling another channel within a workspace, or FTP, which refers to transferring a document to a registered FTP service.

[0259] Therefore, as shown in the example of this drawing, an integration flow can be developed using a connector that includes input / output (From connector / To connector) coding elements of the route through graphic coding.

[0261] Figure (b) of this drawing illustrates an example of graphically coding a service among the integration flow functions when developing an integration flow based on an embodiment.

[0262] According to the embodiment, an integration flow that can be developed graphically can be coded based on a visual interface using service blocks.

[0263] In the example of this drawing, the service block may include graphically provided getNextControlNumber element, isDuplicatedControlNumber element, putUsingControlNumber element, remoteCache element, etc.

[0264] The getNextControlNumber element signifies the issuance of a new control number, and the isDuplicatedControlNumber element checks for duplicate control numbers.

[0265] In this drawing, you can define cases where control numbers are duplicated (True) and cases where they are not duplicated (False).

[0266] In developing an integration flow, among the service blocks, the putUsingConrolNumber element stores the used control number in storage to check for duplicates, and the remoteCache element exemplifies accessing the workspace's cache service.

[0267] Therefore, the integration flow can be coded graphically using service blocks such as the example in this diagram.

[0269] Figure 14 shows an example of graphically coding the processor, control flow, and modifier among the integration flow functions when developing an integration flow based on an embodiment.

[0270] According to the embodiment, an integration flow that can be developed graphically can be coded based on a visual interface using processor blocks.

[0271] In example (a) of this drawing, the processor block may include graphically provided log elements, process elements, xslt elements, groovy elements and delay elements, etc.

[0272] The log element records necessary details in the package log during flow execution, and the package log can be viewed in the adapter that monitors the package's execution status.

[0273] The process element allows you to perform custom processing by calling methods of Beans registered in the uploaded Java (Jar) package items.

[0274] XSLT elements can select XSLT package items to perform XSLT transformations.

[0275] The groovy element allows you to call a script by selecting a Groovy package item.

[0276] The delay element can cause the flow route to be delayed for a short time.

[0277] Therefore, the integration flow can be coded graphically using processor blocks such as the example in this diagram.

[0279] According to the embodiment, an integration flow that can be developed graphically can be coded based on a visual interface using a control flow block.

[0280] In example (b) of this drawing, the control flow block may include graphically provided split elements, for elements, while elements, xslt elements, If or Switch-Case elements and Try-Catch elements, etc.

[0281] The split element logs necessary information during flow execution, and this package log can be viewed in the adapter that monitors the package's execution status. The split element is a feature that allows a single integrated document (Exchange) to be split and processed into multiple Exchanges, and it supports Delimiter, XPath, and Bean methods.

[0282] The for element is used when processing a message multiple times, providing the ability to process it in a different way for each iteration.

[0283] The While element provides the ability to enable a while loop that loops until the Simple expression evaluates to false or null.

[0284] If or Switch-Case elements provide the ability to route messages to the correct destination based on the content of the message exchange.

[0285] The Try-Catch element can support the same exception handling functionality as Java's Try-Catch.

[0286] Therefore, the integration flow can be coded graphically using the example control flow block.

[0288] According to the embodiment, an integration flow that can be developed graphically can be coded based on a visual interface using modifier blocks.

[0289] In example (c) of this drawing, the modifier block may include graphically provided loadProperty element, setProperty element, setHeader element, setBody element, removerHeader element and removeProperty element, etc.

[0290] The loadProperty element provides the functionality to retrieve a configuration node from the configuration store and save it to the Exchange Property.

[0291] The setProperty element can provide the functionality to assign a value to an Exchange Property.

[0292] The setHeader element can provide the functionality to specify a value for an Exchange Message Header.

[0293] The setBody element can provide the functionality to specify a value in the Exchange Message Body.

[0294] The removerHeader element can provide the functionality to remove values ​​from Exchange Message Headers.

[0295] The removeProperty element can provide the functionality to remove a value from an Exchange Property.

[0296] You can code an integration flow graphically using the example modifier blocks.

[0298] Below, an example is disclosed in which users, such as clients, can be distinguished and each workspace isolated according to the embodiment disclosed above.

[0299] If the software packages provided to clients using the workspace are identical, and the same software image is executed for each client, then all versions and types of software packages must be prepared and provided for each client.

[0300] However, according to the embodiments disclosed below, even if application services are provided using the same software package, resources can be utilized efficiently and isolated services can be provided for each workspace used by the client.

[0301] A detailed example is as follows.

[0303] Above, an example was disclosed in which a client or partner uses a channel to transmit and receive relevant information based on a platform provided by the manager system.

[0304] The following discloses an embodiment in which a client and a partner as described above can transmit and receive data while maintaining information security. The above disclosed example involves an agent within the client or partner and an agent adapter within a platform provided by an instance system transmitting and receiving information to and from each other.

[0305] Accessing the client or partner system without installing an agent can cause security issues. To avoid this problem, the client or partner may install an agent. Additionally, the manager system can facilitate patching or upgrades by utilizing the agent installed within the client or partner.

[0306] In addition, the agent adapter can perform protocol conversion or data conversion for data transmission and reception, so it can convert the channel or protocol for data transmission and reception transmitted from the agent to facilitate communication.

[0307] The agent can manage connection information, such as for installed client or partner systems. In this case, the agent can configure connection information for resource access on the client or partner systems. For example, the agent can configure the database, file system, user information, or resource access and management information of the installed system. Additionally, it can poll information from the agent adapter according to configured intervals or conditions.

[0308] Agent adapters within the platform provided by the instance system can be installed on the instance system as application packages. The agent adapter can be configured to collect or store information from registered agents according to configured cycles or conditions when an agent installed on a client or partner system is registered.

[0309] The instance system coordinator can configure a channel that can connect with an agent. Then, when a request is received from an agent through the configured channel, the coordinator can map that channel and forward it to the agent adapter of the worker node.

[0310] When installed on a client or partner's system, the agent may have various configuration information. For example, an agent application may have configuration information including agent-related configuration information, security key information related to agent execution, resource management configuration information, user management information, etc.

[0311] The platform of the instance system can provide a connection interface that allows a client or partner to download and run an agent application.

[0312] The following describes an example of a user interface for an agent or agent adapter and explains how to control it.

[0314] FIG. 15 is a diagram illustrating the interface of an agent when the agent provided on the platform of an instance system according to an embodiment is executed.

[0315] A client or partner can run an agent application by installing the agent application provided by the platform of the instance system.

[0316] This diagram illustrates the interface of the agent when the agent application is executed and the agent is launched by an administrator or user.

[0317] The client or partner's administrator can check the status menu (2115) that indicates the current status through the agent.

[0318] The administrator can check agent public key information, information for synchronizing the agent and agent adapter, status messages in case of synchronization error, etc. from the status menu (2115).

[0319] And the administrator can obtain information from the status menu (2115) about whether the channel set in the agent adapter is connected to the resource, the connection time, and the connection status.

[0320] The administrator of a client or partner can use a menu (2120) to manage their own resources that can be managed through an agent. In the example of this drawing, the resource management (2120) menu is a resource that can be managed by being included in the client or partner system, such as a database, directory, SAP system, or IBM MQ system. The administrator can manage resources through the resource management (2120) menu and set location information or connection information and connection paths for each resource.

[0321] Additionally, the administrator of a client or partner can use the user management menu (2130) to manage agent users through the agent. The administrator can use the user management menu (2130) to manage agent users and set the permissions for each user.

[0323] FIG. 16 is a diagram illustrating an example of an interface of an agent adapter provided by the platform of an instance system according to an embodiment.

[0324] A client or partner may use agent adapters provided by the platform of the instance system. A client or partner may register agents exemplified in the agent adapters provided by the platform of the instance system.

[0325] This drawing illustrates an interface of an agent adapter, and according to this example, a client (or partner) can register to the agent adapter an identifier (2210), a name (2220) of an agent installed on a partner (or client) system that can communicate with each other, a description (2230) of an agent, etc.

[0326] The interface of the agent adapter may include a message box slot (2240) for storing documents or information received by the agent, and a message box slot (2250) for storing documents or information transmitted by the agent.

[0327] And the interface of the agent adapter may include agent public key (2290) information for agent authentication. Here, the hash value of the public key is exemplified as agent public key information.

[0328] The interface of the agent adapter includes means (2295) capable of enabling connection or synchronization with the agent registered as above. This example discloses an example in which the agent adapter transmits and receives information with the agent through a button (2295) that is synchronized (active) with the agent.

[0329] As described above, the agent adapter can register the agent's configuration information, and the agent's configuration information can be stored in the configuration repository of the worker node where the agent adapter is installed.

[0330] In this way, agent configuration information installed on a client or partner can be registered or modified using the agent adapter. An agent configured through the agent adapter can connect to the resources of the system where it is installed and transmit and receive data with the instance system.

[0331] As explained, a transmission channel refers to a channel that retrieves information from the resources of a partner (or client) system at a specific interval and transmits it to the client (or partner) system. A reception channel refers to a channel that stores information received from the client (or partner) system in a configured format at a configured location on the partner (or client) system.

[0332] Therefore, the setting of the transmission channel here refers to the setting to retrieve information or documents from an agent installed on the client or partner's system and store them in a message box.

[0333] And the receiving channel setting refers to the setting to store information or documents received by the agent adapter through the channel setting at a location on the client or partner's system.

[0334] Examples of channel settings are described in detail below. The agent adapter can control the transmission and reception of information or documents through such channel settings.

[0336] FIG. 17 is a diagram illustrating another example of an interface of an agent adapter provided by the platform of an instance system according to an embodiment.

[0337] The channel types configured on agent adapters installed on nodes of the instance system may differ, and agent adapters can set different configurations for transmit and receive channels. The channel type configured on each adapter can be the same as the type of resource managed by the agent.

[0338] This diagram illustrates resources managed by an agent. In this example, the agent manages the database, directories, SAP systems (SAP JCO) within the system where the agent is installed, and IBM systems (IBM MQ) within the system.

[0339] In this case, the agent adapter can set the channel type for the database to JDBC (Java Database Connectivity) (2310), which is a Java API that can connect to the database, and for the directory to set the channel type to a file (FILE) (2320) that can be sent to and received in the directory.

[0340] Here, the agent adapter can set the Java connector (JCO) (2330) as the channel type for SAP systems and the network software message queue (MQ) (2340) as the channel type for IBM systems.

[0341] Here, SAP systems and IBM systems are used as examples, and even if client or partner systems include other systems, the channel type associated with those systems can be configured.

[0343] FIG. 18 is a diagram showing an example of an agent adapter of a platform of an instance system according to an embodiment establishing a transmission and reception channel.

[0344] This example illustrates how to set up the transmission channel for the agent adapter (top) and how to set up the reception channel (bottom), respectively.

[0345] In this example, when setting up the send channel (top), assume that the agent ID of the agent that the agent adapter transmits is test-agent, the channel ID is file-send, the adapter type is file, the direction is send, and the adapter version is 1.0.

[0346] The agent adapter can set the unit of the polling schedule to seconds or crons, and can configure the channel depending on the adapter type.

[0347] In the illustrated example, source information (2410), which is location information of a file for a transmission channel, can be set. Here, as source information (2410), a directory name (file-send), a file name or extension (*.txt), a file encoding type (UTP-8), etc., can be set.

[0348] And after transmitting information to the transmission channel, a processing mode (2420), a time information for checking whether there is a change on the set channel (modification check wait millis) and a maximum file size information (2430) can be set.

[0349] In this example, when setting up the receiving channel (bottom), it is assumed that the agent ID receiving from the agent adapter is test-agent, the channel ID is file-recv, the adapter type is file, the direction is transmission, and the adapter version is 1.0.

[0350] This example illustrates that location information (file-recv), file name or extension (*.txt), file encoding type (UTP-8), etc. (2450) of a file received through a receiving channel can be set.

[0352] FIG. 19 discloses an example of transmitting EDI data, which is transaction information, using the platform of an instance system according to an embodiment.

[0353] The agent adapter (1350) provided by the instance system according to the embodiment can transmit and receive information to and from the system of the agent (350) installed on the client or partner. In this case, the information transmitted and received can be stored in the message box (2110) of the manager system that provides and manages the instance system.

[0354] An agent adapter (1350) installed on a worker node of an instance system according to an embodiment may include an agent control unit (1351), a transmission / reception setting unit (1352), and a transmission / reception processing unit (1353).

[0355] Meanwhile, the agent (350) installed in the client or partner system may include an agent control processing unit (351), a transmission / reception setting processing unit (353), and a transmission / reception unit (357).

[0356] Generally, since the agent adapter (1350) is a software package, the agent control unit (1351), the transmission / reception setting unit (1352), and the transmission / reception processing unit (1353) may each be logical components of the software. Likewise, since the agent (350) is also a software package, the agent control processing unit (351), the transmission / reception setting processing unit (353), and the transmission / reception unit (357) may each be logical components of the software.

[0357] To transmit and receive data from a client or partner system as transactional data, such as EDI data, the client or partner may install an agent to communicate information with the internal system. This example illustrates a case where the client or partner system includes an SAP ERP system, a database such as an RDBMS, or a message queue from an IBM system as the internal system.

[0358] The agent control unit (1351) can control the agent (350) installed in the client or partner system. For example, the agent control unit (1351) can start, stop, or update the agent (350). In this case, if the agent control unit (1351) updates only the request information to control the agent (350) without directly requesting and controlling the agent (350), the agent control processing unit (351) of the agent (350) can retrieve the updated request information according to a set cycle and perform agent control based on the request information.

[0359] The transmission / reception setting unit (1352) of the agent adapter (1350) can be configured to change the transmission / reception processing information of the agent (350). In this case, the transmission / reception processing information to be changed can be stored in the transmission / reception setting unit (1352) instead of being transmitted to the agent (350).

[0360] Then, the transmission / reception setting processing unit (353) of the agent (350) can periodically retrieve transmission / reception processing information changed by the transmission / reception setting unit (1352) of the agent adapter (1350) and save the transmission / reception processing information to a file. The saved transmission / reception processing information is valid only while the agent (350) is running. If the agent (350) is restarted, the agent (350) can retrieve new transmission / reception processing information from the agent adapter (1350) and process it again. Thus, the agent adapter (1350) can remotely set and control the transmission / reception operation of the agent (350).

[0361] The transmitting and receiving unit (357) of the agent (350) can use the transmitting and receiving processing information stored in a file to retrieve information from an internal system (here, SAP ERP system, RDBMS database, message queue) and transmit it to the transmitting and receiving processing unit (1353) of the agent adapter (1350), or to modify and store the information received from the transmitting and receiving processing unit (1353) of the agent adapter (1350) in the internal system.

[0362] Meanwhile, the transmission and reception processing unit (1353) stores information of the system transmitted by the transmission and reception unit (357) of the agent (350) in a message box (2110) within the manager system, or allows the transmission and reception unit (357) of the agent (350) to receive various information set in the agent adapter (1350) and stores that information in the message box (2110).

[0363] In this way, the platform based on the instance system can install an agent on the client or partner system and enable the installed agent to communicate with the platform's agent adapter, thereby enabling the secure communication of system data of the client or partner.

[0364] In addition, the agent communicates with the agent adapter through authentication, and the agent adapter can remotely configure settings for the agent's data transmission and reception. Therefore, by minimizing the agent adapter's direct configuration of operations or information to the agent, configuration management can be made safe and easy.

[0366] FIG. 20 is a drawing disclosing an embodiment of running an adapter in a workspace according to an embodiment.

[0367] To facilitate the development of adapter packages, the present invention provides a simple method for building various standard linkage protocols and aims to provide an app store (1510) for exchanging adapter packages among developers.

[0368] Here, the app store (1510) may include an adapter package sales section (1501) and an adapter package purchase section (1502). In this case, the app store (1510) may refer to the above-described embodiment and may represent a platform where a developer uploads an adapter package and a user can purchase and download the adapter package. Details regarding this will be described later. In one embodiment, approval from an administrator is required for a developer to sell an adapter package through the app store (1510).

[0369] As described above, a client (wherein the client may include both a developer and a user, 100) can create, execute, and modify various packages in a workspace (1500, 3000). In particular, the client (100) can execute an adapter package in the workspace (1500, 3000). An example of executing an adapter package is as described above.

[0370] In one embodiment, a developer develops an adapter in an application service manager and can run the adapter in a workspace (1500, 3000) to test the developed adapter. At this time, the adapter is installed in the workspace (1500, 3000) in units of adapter packages, and the program (program code and related settings) included in the installed adapter package can be executed on the workspace (1500, 3000).

[0371] In one embodiment, when the adapter is executed, it can interact with the platform described above to resolve requirements. That is, the platform shown in the drawing may be provided through the application service manager described above and is not a concept included in the workspace (1500, 3000).

[0372] The services provided by the platform can support the following functions.

[0373] The message box service represents a service that retrieves and saves sent and received documents.

[0374] The communication protocol access service represents a service for accessing external communication protocols. For example, it represents a service for HTTP / HTTPS and FTP access.

[0375] The configuration store service represents a service that stores and retrieves the settings required for the adapter to run.

[0376] Through this, the platform service provider has the advantage of being able to expect additional revenue and diffusion effects by providing an app store for buying and selling adapters and a workspace (1500, 3000) for developing and running adapters.

[0377] In addition, users can establish various standard linkage protocols through the process of purchasing, installing, configuring, and running the created adapter, and from the perspective of the adapter developer, there is the advantage of being able to generate revenue by developing and selling the adapter.

[0379] FIG. 21 is a drawing disclosing an example of an adapter package.

[0380] A package is a collection of programs (code files or configuration files) installed and executed in a workspace, and includes adapter packages, integration packages, and resource packages. The descriptions of integration packages and resource packages are as described above.

[0381] An adapter package refers to a package that supports the use of various types of protocols and services within a platform for integration. Generally, an adapter package is configured via the web using services within the platform, and the configured settings (channels) can be used by the integration package. This is explained as described above.

[0382] In one embodiment, the adapter package may include the following adapters. That is, a wide variety of requirements can be addressed through the adapter package described below.

[0383] The first adapter package (1520a) may include a protocol adapter. Here, the protocol adapter includes a standard protocol communication adapter such as EDIINT, OFTP, etc.

[0384] The second adapter package (1520b) may include a mapping / conversion program adapter. Here, the mapping / conversion program adapter represents an adapter that facilitates mapping and conversion operations.

[0385] The third adapter package (1520c) may include a web scrap adapter. Here, the web scrap adapter represents a scrap function adapter in a web service that is provided only through web services rather than standard communication.

[0386] The fourth adapter package (1520d) may include a development wizard adapter. Here, the development wizard adapter represents an adapter that generates a connection flow (program flow) of specific patterns in a wizard manner.

[0387] It goes without saying that the adapter package may include other adapters developed by the developer through the workspace in addition to the adapters mentioned above.

[0390] FIG. 22 is a drawing disclosing an example in which an adapter according to an embodiment uses a framework.

[0391] The Core can provide the following services. In this case, the Core corresponds to the aforementioned framework.

[0392] (1) Configuration Repository: Can store and manage configuration information. Through this, system configuration data can be stored and access to necessary configuration information can be provided.

[0393] (2) Distributed Task Service: Allows for the processing and management of tasks in a distributed environment. Through this, tasks can be distributed among multiple nodes or systems, and status tracking can be handled.

[0394] (3) Channel Registry: Responsible for the registration and management of communication channels. Through this, channels for communication between different systems or packages can be registered and used.

[0395] (4) Message Box Service: Can support message-based communication. Through this, it can support asynchronous communication between various systems by providing functions such as message transmission, reception, storage, and routing.

[0396] (5) File Watch System: A system that handles file changes and monitoring, which can monitor changes in the file system and perform necessary tasks.

[0397] The adapter of the present invention can use APIs to use the framework. That is, the adapter can use the core services through APIs.

[0399] APIs can provide the following services.

[0400] (1) Configuration Service: A service interface that provides access to configuration settings and can support viewing, modifying, deleting, etc. of configuration data.

[0401] (2) Task Service: A service interface for using functions related to task processing, which can provide task management functions such as creating tasks, checking status, and returning results.

[0402] (3) Channel Access Service: A service interface that provides access to a communication channel, and can provide functions such as channel creation, message transmission, and reception.

[0403] (4) Message Box Access Service: A service interface that provides access to message boxes, and can provide functions such as creating, sending, receiving, and deleting messages.

[0404] (5) User Class: A class registered in the registry using the API that can be referenced by web services or other classes.

[0405] (6) File Watcher: An interface for handling file monitoring, which can process file change events and perform necessary tasks.

[0407] User implementation can provide the following services.

[0408] (1) Web Service: An implementation code used by users to develop web-based services, which can provide the settings necessary for the adapter to run through a web interface.

[0409] (2) User Classes: Custom classes written by developers to implement their own logic, which can implement specific domain or business logic by utilizing the functions of Core or API.

[0410] (3) File Watcher Implementation: This is implementation code that handles file monitoring. It interacts with the File Watch System to process file change events and perform necessary tasks.

[0412] FIG. 23 is a drawing disclosing an example of a service provided by an adapter package according to an embodiment.

[0413] An Application Context is a component included in the framework and may include service APIs for developing adapter packages. For example, service APIs may include WorkspaceIdentity, MessageAccessService, MessageSlotInfoService, ConfigurationService, TaskService, ChannelAccessService, FileAccessService, etc.

[0414] In one embodiment, the developer of the adapter package may specify a method to be executed according to the life cycle of the adapter package. In this case, the developer may use annotations related to the life cycle. For example, a specific method may be specified to be executed when the package starts or ends. This will be described later.

[0415] Additionally, services registered in the Application Context can interact with User Classes registered as Beans. For example, user implement classes registered as Beans may include FileWatcher, TaskImple, ChannelProcessorImple, and other user-defined classes. These classes implement specific application functions or business logic and are registered as Beans in the application context so that they can be used by other components. Through this, the framework manages instances of User Classes and enables the creation and use of objects required by the application.

[0416] In one embodiment, the Application Context registers a user component as a Bean so that it can be referenced by a web service (e.g., Rest, Servlet). In one embodiment, when referencing a user component from a web service, it is characterized by referencing it directly through the Application Context. The method is as follows.

[0417] Method:

[0418] - T getInstacne(Class <t>type): Returns services and objects registered in the Application Context.

[0419] - WorkspaceIdentity getWorkspaceId(): See WorkspaceIdentity

[0420] - String getPackageId(): Returns the package ID.

[0421] In this case, the Rest API can be implemented via the JAX-RS API. To do this, the REST service is registered using the @RestService annotation, and it can be accessed via / pkg / {workspace_install_path} / {package_install_path} / rest / {path).

[0422] In addition, the Servlet API can be implemented through the javax.servlet API.

[0423] To do this, register the Servlet with @Servlet("Servlet pattern") and access it via pkg / {workspace_install_path} / {package_install_path} / {Servlet pattern}.

[0425] The description of WorkspaceIdentity is as follows. WorkspaceIdentity contains information about the workspace to which the adapter package belongs and can generate tickets. WorkspaceIdentity corresponds to the class for workspace authentication when the adapter package uses cloud EDI services. WorkspaceIdentity is required when using APIs provided by the cloud EDI platform. The method is as follows.

[0426] Method:

[0427] - getId(): Returns the unique ID of the workspace to which the package belongs.

[0428] - getTicket(): Returns a Ticket that authenticates the workspace to which the package belongs.

[0430] The description of TaskService is as follows. TaskService can provide functions related to distributed task scheduling. TaskService can register tasks in a distributed environment and schedule them to run periodically. Tasks registered by the distributed task service can be executed according to a specified time or event.

[0431] In other words, TaskService can be used by adapter packages to register and unregister specific tasks from a distributed scheduler. Users can implement the Task interface, and the distributed scheduler can support Cron or Secondary methods. The method is as follows.

[0432] Method:

[0433] - register(TaskConfig config, Task task): Registers a task with the distributed scheduler

[0434] - return: task unique ID)

[0435] - unregister(String taskId): Unregister a task with a unique ID from the distributed scheduler

[0437] The description of MessageBoxAccessService is as follows. MessageBoxAccessService enables the sending and receiving of documents by accessing EDI message boxes. In one example, it can access a cloud-based message box to transmit data and process received data. Here, a message box represents an API that allows access to the message box storage to save, retrieve, or delete documents. The method is as follows.

[0438] Method:

[0439] - send(): Saves the document to the MessageBox

[0440] - queryPendingMessageList(): Returns a list of message records (message headers) in the waiting state (TBDL, WAIT) for the corresponding slot / pathname.

[0441] - receivePayload(): Returns message body

[0442] - updateMessageStatus(): Change message status

[0443] - deleteMessage(): Delete message

[0445] The description of MessageSlotInfoService is as follows. MessageSlotInfoService corresponds to a service that holds message box slot information. The method is as follows.

[0446] Method:

[0447] - getSlotId(String workspaceId, String pathname): Returns the message slot ID corresponding to the workspace ID and path name.

[0448] - getMessageBoxId(String slotId): Returns the ID of the message box to which the message slot belongs.

[0449] - getSlotMap(String workspaceId): Returns a list of message slots accessible in the workspace.

[0451] The description of ConfigurationService is as follows. ConfigurationService corresponds to a service that accesses the Config Repository to query, modify, or delete configuration information. Through this, configuration data can be managed and necessary configuration information accessed. ConfigurationService represents an API that allows a package to directly access the Config Repository to read, modify, change, or delete the package's configurations. The method is as follows.

[0452] Method:

[0453] - list(WorkspaceIdentity, String packageId, String nodePath): A method for providing a web service that retrieves a list of node paths in the requested path of a specific workspace and package, and fetches configuration information required for the settings screen UI in Web Admin.

[0454] In this case, using FsWatchSystem to apply setting values ​​from the adapter package is recommended.

[0455] - create(WorkspaceIdentity, String packageId, ConfigNode node): Creates a configuration node

[0456] - update(WorkspaceIdentity, String packageId, ConfigNode node): Changes the configuration node

[0457] - remove(WorkspaceIdentity, String packageId, ConfigNode node): Deletes the configuration node

[0459] The description of FileWatchSystem is as follows. FileWatchSystem can provide the functionality to monitor file changes in a given path or directory and perform necessary tasks. More specifically, FileWatchSystem periodically monitors directories in a registered path to detect the creation, modification, or deletion of files, and can perform interfaces through a registered FsWatcher. Here, the FsWatcher can implement actions to be performed when it detects file changes within the path. For example, the method is as follows.

[0460] Method:

[0461] - init(Set <file>fset, String path): Executed when FsWatcher is first registered, passes the FileSet within the registered path as a parameter.

[0462] - process(FsEvent): Returns the file where a change was detected and the event type.

[0464] The description of FileAccessService is as follows. FileAccessService allows you to access files by using the File Access Service to access FTP servers within Cloud EDI or external FTP servers. The method is as follows.

[0465] Method:

[0466] - put(String workspaceId, String serviceName, String folderPath, String filename, byte[] body): Transfers a file to the FTP service path with ServiceNamed registered in the workspace

[0467] - get(String workspaceId, String serviceName, String folderPath, String filename): Retrieves a file located in the FTP service path with ServiceNamed registered in the workspace

[0468] - list(String workspaceId, String serviceName, String folderPath, String pattern): Retrieves a list of files in the target path that match the GLOB pattern

[0469] - delete(String workspaceId, String serviceName, String folderPath, String filename): Deletes a file at the target path

[0471] ChannelAccessService is a component that provides distributed channel access services in response to channel requests, allowing specific processes to subscribe to a channel and process messages or events received from it. Through this, data can be transmitted via the channel and received and processed. The method is as follows.

[0472] Method :

[0473] - create(String channelId, String channelName): Create a channel in the workspace beforehand

[0474] - subscribe(ChannelProcessor processor): Registers the interface to handle the channel as the package's default channel.

[0475] - Subscribe(String channelId, ChannelProcessor processor): Subscribe to a channel with a specific channel ID

[0476] - unsubscribe(): Unsubscribe from the package's default channel

[0477] - unsubscribe(String channelId): Unsubscribe from a specific channel

[0478] - call(ChannelRequest request): Call a specific channel

[0480] FIG. 24 is a drawing disclosing an example of an adapter developed in a workspace according to an embodiment.

[0481] Through the above-described embodiment, a developer can develop a first adapter package (324) that performs the role of a Router. Here, the adapter included in the first adapter package (324) corresponds to a service that facilitates routing by configuration.

[0482] According to an embodiment, the client (310) can provide an application service such as the disclosed example to a desired partner (320). The embodiment not only allows the client (310) to simply provide the service, but also enables the client (310) to directly provide a customized service to the desired partner (320) using the embodiment.

[0483] In this drawing, an embodiment is described in which an EDI service is provided using the first adapter package (324) described above. In order for a client (310) to conduct a transaction with a partner (320), the embodiment may provide a coordinator (1100) and worker nodes (1300a, 1300b) included in an instance system. Here, the first worker node (1300a) and the second worker node (1300b) correspond to the same or different nodes.

[0484] In one embodiment, a first agent (312) is installed in the adapter package (311) with which the client (310) communicates, and the client can request EDI information, which is information required for a transaction, through the first agent (312). Here, the EDI information corresponds to the original EDI message (313).

[0485] The first agent (312) with which the client (310) communicates transmits the received requested EDI information to the message box service (2110). In one embodiment, the message box service (2110) may be provided by an application service manager.

[0486] The message box service (2110) can store the EDI information received from the first agent (312) in the client inbox (2111).

[0487] Subsequently, the EDI information can be transmitted to the first adapter package (324) running on the first worker node (1300a) within the instance system. Here, the first adapter package (324) can perform the role of a router as described above.

[0488] In one embodiment, the first adapter package (324) may store EDI information containing the Original EDI Message (313) in the first partner outbox within the message box service (2110) based on information received from the coordinator (1100). Additionally, the first adapter package may transmit EDI information containing the Original EDI Message (313) to the integration package (1380) of the second worker node (1300b) based on information received from the coordinator (1100). At this time, the first adapter package may refer to the Distributed Scheduler of the coordinator (1100) and look up the Adapter Channel Registry.

[0489] The integration package (1380) can convert the EDI information received through the above-described embodiment. At this time, the integration package (1380) can subscribe to an adapter channel registry. Here, subscription refers to the process of registering (subscribing) the "distributed channel name" to be called when a specific flow or logic of the integration package is called from the router package. For example, the router package of Node #1 can call the channel by looking up the coordinator (1100) to see which node the channel is on.

[0490] Accordingly, the second worker node (1300b) containing the integrated package (1380) can store EDI information containing the Transformed EDI Message (314) in the second partner outbox of the message box service (2110).

[0491] Subsequently, the message box service (2110) can transmit EDI information containing the Original EDI Message (313) stored in the first partner outbox to the first partner (322) of the adapter package (321) communicating with the partner (320). Additionally, the message box service (2110) can transmit EDI information containing the Transformed EDI Message (314) stored in the second partner outbox to the second partner (323) of the adapter package (321) communicating with the partner (320). Here, the first partner (322) and the second partner (323) correspond to the trading partners of the client company. This is because the client company can exchange documents with multiple partners.

[0492] As a result, the partner (320) can receive the EDI information transmitted by the client (310) as standardized EDI converted data. Even when the partner (320) transmits its own EDI information to the client (310), the data can be transmitted according to a similar process.

[0493] Accordingly, the client (310) and the partner (320) can easily use application services such as EDI services according to the disclosed embodiment, and can easily proceed with transactions according to the standardized format even if they do not know the standardized format or do not accurately understand the documents and information requested by the counterparty.

[0494] Additionally, the client (310) or partner (320) may develop or use such an adapter package in their workspace and may link it to an integration package (1380). The embodiment may provide a very easy interface for developing such a package and connecting it to an existing package, and the developed package may also be sold, shared, or provided separately.

[0496] FIG. 25 is a drawing disclosing an example in which an application service providing device according to an embodiment converts a data format.

[0497] In the illustrated example, the application service providing device (300) may include an instance system (not illustrated) and a manager system (not illustrated). The instance system may include a worker node (e.g., Node #N) with an agent adapter (1350) and a mapping adapter (1370) installed, and may provide application services to a client (100) and a partner (200).

[0498] The manager system (not shown) may include an application service manager (2100), and the application service manager (2100) may obtain data collected from the agent (350) of the client (100) and the agent (450) of the partner (200) from an agent adapter (1350) installed on a worker node. The mapping adapter (1370) may unmarshall the source document data of the client (100) and output it as target document data mapped to the information required by the partner (200).

[0499] Accordingly, an application service providing device (300) according to an embodiment of the present invention may include an agent adapter (1350), a mapping adapter (1370), and an application service manager (2100).

[0500] The agent adapter (1350) may include a transmitting and receiving unit (810). The transmitting and receiving unit (810) may receive source document data from the agent (350) of the client (100). For example, the source document data may be expressed as text data. In one embodiment, the source document data received from the agent (350) may be stored in a message box (2110) included in the application service manager (2100).

[0501] The mapping adapter (1370) may include a deserialization unit (820), a mapping unit (830), and a serialization unit (840). In this case, the deserialization unit (820) may convert source document data having a first data format into source structure data based on a pre-stored source schema. The mapping unit (830) may convert source structure data into target structure data based on at least one of a pre-stored source schema, a pre-stored mapping script, or a pre-stored target schema. The serialization unit (840) may convert target structure data into target document data having a second data format based on a pre-stored target schema. In one embodiment, the converted target document data may be stored in a message box (2110).

[0502] In one embodiment, at least one of the source schema, mapping script, or target schema may be generated based on user input from the client (100) or partner (200) to the graphic user interface (GUI) of the platform of the instance system (1000) provided to the client (100) or partner (200), and may be received through an agent adapter (1350) and stored in advance in a message box (2110).

[0503] The agent adapter (1350) can receive target document data having a second data format converted from source document data having a first data format from the message box (2110) and transmit it to the agent (450) of the partner (200).

[0505] FIG. 26 is a drawing disclosing an example in which an application service providing device according to an embodiment converts a data format using a schema and a mapping script.

[0506] The deserialization unit (820) can convert source document data having a first data format into source structure data based on a pre-stored source schema. In one embodiment, the first data format may include at least one of a first data format or a first data structure.

[0507] The deserialization unit (820) can convert source document data (e.g., text) into source structure data (i.e., internal structure) as the reverse of serialization. In other words, the deserialization unit (820) can parse source structure data from source document data.

[0508] That is, the deserialization unit (820) can perform deserialization (parsing) to create an internal data structure that can map source document data (i.e., original data) based on the structure information and annotation information of the source schema for source document data.

[0509] The mapping unit (830) can convert source structure data into target structure data based on at least one of a pre-stored source schema, a pre-stored mapping script, or a pre-stored target schema. In one embodiment, the mapping script may include at least one of statement information representing the grammar of a programming language or expression information representing a specific result value.

[0510] In one embodiment, the mapping unit (830) can perform mapping that converts source structure data into target structure data using structure information including the structure (tree) and name (Identifier) ​​of the source document data.

[0511] In one embodiment, at least one of the source schema, mapping script, or target schema may be stored in a mapping program. The mapping unit (830) can convert source structure data into target structure data based on the mapping program, wherein the annotation information of the source schema and target schema is used only in serialization and deserialization and is not used in the mapping program. This is so that the mapping based on the mapping script focuses exclusively on mapping data between the schema nodes of the source schema and the target schema.

[0512] That is, according to the present invention, by intentionally separating the roles of the mapping script and the annotation information of the schema (SoC - Separation of Concerns), the mapping script is used intensively only for mapping regardless of serialization and deserialization, and the annotation information of the schema is used intensively only for serialization and deserialization, thereby effectively supporting specialized language language (DSL)-based mapping.

[0513] Additionally, according to the present invention, serialization and deserialization are performed to convert a data format (i.e., at least one of a data format or a data structure), and mapping can be performed to convert source structure data into target structure data regardless of the conversion of the data format.

[0514] The serialization unit (840) can convert target structure data into target document data having a second data format based on a pre-stored target schema. In one embodiment, the second data format may include at least one of a second data format or a second data structure. That is, for example, the target document data may have a different data format from the source document data. Also, as another example, the target document data may have the same data format as the source document data but a different data structure.

[0515] Specifically, the serialization unit (840) can perform serialization that converts target structure data into target document data (e.g., text) having a second data format based on pre-stored structure information and annotation information of the target schema.

[0516] For example, the serialization unit (840) can convert target structure data contained in internal program language variables into target document data such as EDI, XML, or JSON.

[0517] Accordingly, according to the present invention, a Domain Specific Language (DSL) for defining a schema to serialize / deserialize documents of various data formats using annotation information may be used.

[0518] In addition, according to the present invention, a self-mapping script language capable of solving various mapping requirements with the syntax of a relatively simple programming language can be provided.

[0519] In addition, according to the present invention, a unified schema definition grammar can be provided for documents of various data formats.

[0520] In addition, according to the present invention, it is possible to provide a function that can create mappings ranging from simple to complex through a relatively simple mapping script language and Lua custom function functions.

[0521] In addition, according to the present invention, by providing these functions as a DSL, it is possible to easily develop functions.

[0523] FIG. 27 is a drawing disclosing an example of deserialization and serialization based on a schema according to an embodiment.

[0524] In one embodiment, deserialization can be performed to convert document data into structured data based on a schema for the document data. For example, the document data may include various types of document data, such as EDI documents, XML documents, and JSON documents. In this case, deserialization may be referred to as unmarshaling or a term having an equivalent technical meaning. In one embodiment, the document data for deserialization may include source document data, and the structured data may include source structured data.

[0525] In one embodiment, serialization can be performed to convert structural data into document data based on a schema for document data. In this case, serialization may be referred to as marshalling or a term having an equivalent technical meaning. In one embodiment, the structural data for serialization may include target structural data, and the document data may include target document data.

[0526] In one embodiment, the schema may include at least one of structural information or annotation information for document data. The structural information represents the structural data of the document data and may include data defined as a data type. For example, the data type may include at least one of Primitive, Record, Array, or TypeRef.

[0527] Primitives can specify primitive types such as string, int, long, double, and decimal. For example, String represents the string data type, and Int represents the integer data type. A Record can have other types as subtypes and can consist of a collection of data of different types. An Array can be defined as an array of a specific type and can consist of a collection of data of the same type. A TypeRef can be retrieved by referencing an already defined Record.

[0528] In one embodiment, the comment information corresponds to a data type and may include information used when recognizing (parsing, deserializing) the corresponding data in the document data. For example, @XmlElement(name="”) may represent a comment, and the XmlElement listed after @ represents the name of the comment, includes an element named name, and its value may be "employee".

[0529] Additionally, for example, if the @JsonProperty(name=”” annotation information is included in the schema, the box display of the JSON document may be displayed as employee-id instead of id according to the annotation information during marshalling. On the other hand, if the @JsonProperty(name=”” annotation information is not included in the schema, the box display of the JSON document may be written as id according to the int id; structure information of the schema during marshalling. In one embodiment, such a schema may be defined as Backus-Naur Form (BNF), which is a grammatical expression that can define the syntax of a programming language.

[0531] FIG. 28 is a drawing disclosing an example of a mapping script according to an embodiment.

[0532] A mapping script can be used to convert source structural data into target structural data in accordance with the form of the target schema. In one embodiment, the mapping script may include at least one of statement information representing the grammar of a programming language or expression information representing a specific result value.

[0533] Here, sentence information may represent each line of the programming language of the mapping script. That is, the mapping script may be composed of sentence information. In one embodiment, the sentence information may represent the correspondence between the structural information of the source schema and the structural information of the target schema.

[0534] For example, statement information may include MapStmt, LoopStmt, IfStmt, MatchStmt, LoopVarSetStmt, and LoopVarIncStmt, but is not limited to these and may include various other statement information. In this case, MapStmt may include statement information that performs mapping. LoopStmt may include statement information representing a loop and can perform a function similar to a for loop in general programming languages. IfStmt may include statement information representing a conditional statement and can perform a function similar to an if statement in general programming languages. MatchStmt may include statement information representing a conditional control statement and can perform a function similar to a switch statement in general programming languages. LoopVarSetStmt may declare variables to be used within the loop. LoopVarIncStmt may include statement information that increments a specific variable (e.g., LoopVar).

[0535] Additionally, expression information can specify where to retrieve the value to be used and can represent an expression that is reduced to a single value through evaluation. For example, expression information may include Constants, Paths, Custom Functions, and LoopVars, but is not limited to these and can include various other expression information. In this case, a Constant can be represented by directly specifying a String or a Number. A Path can represent a specific path in a Source. A Custom Function can represent a function created by the user. A LoopVar represents a variable for a Loop statement, and can represent a LoopVar such as #i.

[0536] In one embodiment, the mapping script may be included in a mapping program. In one embodiment, such mapping script may be defined as a BNF, which is a grammar expression capable of defining the syntax of a programming language.

[0538] The following discloses an embodiment in which a client or partner can develop a necessary application based on an application package downloaded from a workspace.

[0539] Clients or partners can access their workspace on the platform of the instance system and develop applications necessary for various tasks or transactions based on the graphic user interface (GUI) provided by the platform.

[0540] For example, if a client develops an application that transmits EDI information as a service, the client can develop a mapping program capable of mapping standardized transaction information with partners and provide information to partners based on this. Alternatively, the client can sell the mapping program developed in this way itself on the manager system's platform.

[0541] While a mapping program is exemplified here, clients or partners require the mapping of different information or documents depending on the type of business or transaction they operate. Here, mapping refers to the process of transforming data 'a' (source) with schema A into data 'b' (target) with schema B. In this context, a schema represents the structure of the data, and nodes with specific names have a hierarchical structure.

[0542] Because the types of such businesses are very diverse, the embodiments herein disclose an example in which a mapping program capable of mapping EDI information to a user can be developed very easily.

[0543] A platform according to an embodiment may provide an environment and interface for developing a mapping program, which is disclosed in detail as follows.

[0545] FIG. 29 is a drawing that discloses an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0546] The user interface for developing the mapping flow of the present invention may include a development tool palette (901) and a development GUI code area (902).

[0547] Here, the development tool palette (901) may include graphic blocks corresponding to the structures and functions of the language used in the mapping program. That is, the development tool palette (901) may include a list of all keywords used in the mapping program. For example, the development tool palette (901) may include graphic blocks corresponding to control structures and functions used in the mapping program, such as "Statements", "MAP", "If", "Then", "Loop for", "LoopVar", "LoopVar++", and "Match". However, the functions included in this drawing are merely examples, and it goes without saying that other functions may be included.

[0548] In one embodiment, the application service provision method may provide a user interface including a development tool palette (901) and a development GUI code area (902). Within the user interface, the user may select a graphic block included in the development tool palette (901) and then drag and drop it to the development GUI code area (902).

[0549] For example, when the user interface receives an input signal (903a) in which the user selects a graphic block of the first function (e.g., a "Statements" block) and drags and drops it into the development GUI code area, the graphic block of the first function can be output from the development GUI code area (902). At this time, the drag and drop input signal is merely an example and may include other pre-configured input signals received from the user.

[0550] Here, the "Statements" block must be the top-level block of the mapping program, as it is a block that sequentially contains other blocks. In other words, the "Statements" block corresponds to the block containing the beginning and end of the mapping program.

[0551] Subsequently, when the user interface receives an input signal (903b) in which the user selects a graphic block of the second function (e.g., "LoopVar" block) and drags and drops it into the development GUI code area (902), the graphic block of the second function can be output in the development GUI code area (902). At this time, the development GUI code area (902) can be configured to automatically include the second function within the first function.

[0552] In addition, the development GUI code area can output the input fields of the parameters included in the graphic block of the second function as they are. Referring to the "LoopVar" block mentioned above, the "LoopVar" block in the developer tool palette is a block that declares the loop variable to be used in the "Loop for" block, and the "variable name" and "initial value" must be set. Accordingly, since the "LoopVar" block has two input fields for parameters (variable name, initial value), the input fields of the parameters can be output as they are in the development GUI code area while outputting the "LoopVar" block.

[0553] Afterwards, the user can directly enter parameters into the input fields of the "LoopVar" block. For example, the user can enter the variable name "k" and the initial value "1" into the "LoopVar" block. Accordingly, the development code can declare a loop variable named k in the loop and assign 1 as the initial value.

[0554] Subsequently, when the user interface receives an input signal (not shown) in which the user selects a graphic block of a third function (e.g., a "Loop for" block) and drags and drops it to the development GUI code area (902), the graphic block of the third function can be output in the development GUI code area (902). At this time, the development GUI code area (902) can be configured to automatically include the third function within the first function after the second function.

[0555] As such, the user interface for developing the mapping flow of the present invention can provide visual assistance to the user in forming a code structure in the development GUI code area (902) using graphic blocks included in the development tool palette (901). This has the advantage that the user can define a mapping program relatively easily even if they are not familiar with development scripts.

[0557] FIG. 30 is a drawing that discloses an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0558] The user interface for developing the mapping flow of the present invention may provide development source code (905) corresponding to the development GUI code area (902).

[0559] More specifically, the application service provision method can output source codes corresponding to functions output in the development GUI code area (902) onto the development source code area (904). That is, referring to the above-described embodiment, when a user selects a graphic block included in the development tool palette to output a function to the development GUI code area (902) and inputs parameters corresponding to the function, the application service provision method can generate and output source code (905) corresponding to the function and parameters onto the development source code area (904).

[0560] In one embodiment, when a user directly modifies the source code (905), the user interface for mapping flow development can reflect the source code in real time and output a graphic block corresponding to the modified source code (905) in the development GUI code area (902).

[0561] Through this, developers can visually configure a mapping program through the development tool palette and the development GUI code area (902) and convert it into source code (905) for verification.

[0562] However, while developers unfamiliar with programming can easily access the user interface of the present invention, developers familiar with programming may find the source code method, which displays the program in a concise manner, more familiar, and the source code method may be more productive in the flow of a mapping program where a large amount of mapping is performed repeatedly.

[0563] That is, through the present invention, the developer can selectively use a method of directly modifying the source code area (904) according to their personal preference or dragging and dropping graphic blocks in the development GUI code area (902).

[0564] This GUI-based, easy-to-use mapping program definition tool enables developers to easily implement and manage complex mapping logic through a user-friendly interface and visual programming methods.

[0566] FIG. 31 is a drawing that discloses an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0567] In one embodiment, the application service provision method may provide a user interface (UI) for developing mapping flows by utilizing a GUI-based library. In this case, Google’s Blockly library may be used as a GUI tool for developing or editing mapping flows, but is not limited thereto.

[0568] More specifically, the user interface for developing a mapping flow may include a mapping program editing screen and a function editing screen.

[0569] The present drawing illustrates a mapping program editing screen. In one embodiment, the mapping program editing screen may include a mapping program area (906), a source schema area (907), a target schema area (908), and a mapping expression area (909).

[0570] Here, the mapping program area (906) may include the aforementioned development tool palette and development GUI code area. That is, in the mapping program area (906), the user can perform a conversion between a complex source schema and a target schema by arranging the necessary blocks (statements) in a flow order.

[0571] In one embodiment, the mapping program area (906) may include an icon (910) for outputting a source code area. When a user selects the icon (910), the user interface may output a source code area popup window for outputting source code corresponding to the development GUI code included in the mapping program area (906). Here, the source code area popup window may include the development source code area described above.

[0572] Additionally, in one embodiment, the user can select a MAP block among the development GUI code being output within the mapping program area (906). Accordingly, the user interface can output a source schema and a target schema corresponding to the map block to the source schema area (907) and the target schema area (908), respectively.

[0573] More specifically, the source schema area (907) represents information about the data schema before conversion. In one embodiment, the user can add or delete information about the source schema.

[0574] The target schema area (908) represents information about the data schema after conversion.

[0575] The source schema area (907) and the target schema area allow for easy connection between the source schema and the target schema nodes.

[0576] Additionally, in one embodiment, the user interface may output a mapping line between a node included in the source schema and a node included in the target schema. Through this, the user can visually determine whether a node in the source schema is mapped to a node in the target schema.

[0577] In addition, in another embodiment, when the user interface receives an input signal in which a node included in the source schema is selected and then dragged and dropped to a node included in the target schema, it can automatically output the corresponding mapping expression to the mapping expression area (909).

[0578] The mapping expression area (909) is an area for performing mappings between actual nodes, and is displayed when a mapping block is selected among the preceding blocks (Statements), allowing multiple mapping expressions between each node to be inserted. That is, it corresponds to an area for setting the detailed values ​​of the mapping expression. This will be described later.

[0580] FIG. 32 is a drawing that discloses an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0581] The mapping representation area (909) corresponds to an area that performs mapping between actual nodes. In one embodiment, when a user selects a map block among the blocks included in the mapping program area (906), the user interface may provide a GUI block on the mapping representation area (909) that allows input of a path, data type (e.g., String), function, and input value (Arguments) included in the mapping block.

[0582] Accordingly, the user can select a function block to choose one of the various functions used in the mapping block. The various functions used in the mapping block will be described later.

[0584] FIG. 33 is a drawing that discloses an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0585] In one embodiment, a user interface for developing a mapping flow may provide a schema editing screen. Here, the schema editing screen may include a schema editing area (911) and an annotation area (912).

[0586] As described above, the schema editing area (911) is an area where the user edits the schema used in the mapping flow, and is illustrated as an example in this drawing. Here, the schema editing area (911) represents the structure of the data and can represent a hierarchical structure of named nodes. Here, each node can have a Type such as Int, String, etc. For example, the user can create a sample node in the mapping program area and set the data type or structure for each node. For example, "String" represents a string data type, and "Int" represents an integer data type.

[0587] The annotation area (912) corresponds to an area for editing information necessary when the data is expressed as text (serialization), in addition to the hierarchical structure of the data. Additionally, the annotation area (912) corresponds to an area for editing information additionally necessary when the data is recognized from text (parsing, deserialization), in addition to the hierarchical structure of the data. Accordingly, the annotation area (912) may include an annotation list (913). Here, the annotation list (913) may include an annotation name and a document type.

[0588] In this case, multiple comments can be added per node, but multiple comments with the same name cannot be added. Each comment comes in various types depending on the document type (XML, JSON), and each comment can have unique attributes (arguments).

[0589] For example, "ZmlAttribute" can indicate that when the node is serialized or deserialized into XML, this node is an attribute rather than an element of XML.

[0590] Additionally, the comment area (912) may further include a user comment list (914). Here, the user comment list (914) may add name and namespace as unique attributes (arguments) corresponding to existing comments, but they are not mandatory values. That is, both name and namespace can be added optionally. Here, name can be used to describe the role or meaning of the argument, and namespace can be expressed in the form of a Uniform Resource Identifier (URI) to identify the logical group to which the attribute belongs. In the example described above, in "XMLAttribute", name can be specified as an additional attribute if the XML Attribute name is different from the node name, and namespace can be specified if the XML Attribute belongs to a specific XML namespace.

[0591] These are subsequently used in interactions with XML or JSON and can indicate how specific members should be processed during the data serialization or deserialization process.

[0593] FIG. 34 is a drawing that discloses an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0594] As described above, users can customize the functions included in the mapping block. When a mapping program attempts to map data from a source schema to a target schema, it can create the necessary functions and use them within the mapping representation area.

[0595] In one embodiment, the function editing screen provided by the user interface for developing a mapping flow may include a function list area (915) and an editing area (916).

[0596] The function list area (915) represents an area where the user can customize functions. For example, the user can create a function and set the number of parameters for the function. For example, the "concat" function performs the role of concatenating strings, so it is a function that combines given strings into one to create a new string. Accordingly, the "" function can receive two strings as parameters.

[0597] The user can add functions to the function list through the + button included in the function editing screen. Additionally, the user can edit the functions displayed in the function list area through the edit button, and delete the functions displayed in the function list area (915) through the delete button.

[0598] The editing area (916) corresponds to an area for editing information about the function selected in the function list area (915).

[0599] Here, each function performs its own operation and can be usefully utilized in programming or data processing tasks. Users can create functions with different implementation methods and syntax depending on the actual language or context being used.

[0601] FIG. 35 is a drawing disclosing an example in which an application service providing device according to an embodiment generates and tests an integrated package.

[0602] In the illustrated example, the application service providing device may include a manager system (2000). In this case, the manager system (2000) may include an application service manager (2100) and a database (2200).

[0603] The application service manager (2100) provides the client (310) with a user interface including a development tool for an integration flow for an integration package, and can create an integration package through a drag-and-drop GUI (graphical user interface) based development tool by the user of the client (310).

[0604] In one embodiment, the application service manager (2100) may include a user interface processing unit (921), an integrated package creation unit (922), an integrated package testing unit (923), and an integrated package provision unit (924).

[0605] The user interface processing unit (921) may provide the client (310) with a user interface that includes a development tool for an integration flow for an integration package. In one embodiment, information about the integration flow of the integration package may be stored in a database (2200) in an editable form.

[0606] In one embodiment, upon receiving an input signal for a development tool of an integration flow from a client (310), the integration package generation unit (922) can generate an integration package corresponding to the input signal.

[0607] In one embodiment, an integrated package can be created based on an input signal in which a user of the client (310) selects a graphic block corresponding to a development tool within the user interface and drags and drops it into the development GUI code area.

[0608] That is, according to the present invention, an integration flow for an integrated package is intuitively defined through a drag-and-drop method, and an easy integrated package can be created by providing a form for inputting necessary parameters for each graphic block. The integrated package test unit (923) can distribute the integrated package to the development workspace (3000) and perform integrated package testing and debugging.

[0609] The integration package provider (924) can distribute the integration package to the workspace of the client (310). That is, the integration package can be distributed to and executed in the workspace of each client (310) for actual integration, and the client (310) can periodically perform desired integration tasks through the integration package.

[0610] In one embodiment, the application service providing device may further include an instance system (not shown). In this case, prior to the execution or testing of the integration package, information regarding the integration flow may be packaged into the integration package, installed on the instance system, and executed.

[0611] Subsequently, when the integrated package is executed, the integrated package can exchange information with the message box of the application service manager (2100), the agent adapter of the instance system, and the channel service of the coordinator to enable the implementation of various requirements that allow the client (310) and the partner to transact.

[0613] FIG. 36 is a drawing disclosing an example of providing a user interface for developing an integrated flow according to an embodiment.

[0614] In one embodiment, the user interface for developing an integrated flow of the present invention may include a development tool palette and a development GUI code area.

[0615] Here, the development tool palette may include graphic blocks corresponding to the structures and functions of the language used in the integration package. That is, the development tool palette may include the entire list of keywords used in the integration package. For example, the development tool palette may include graphic blocks corresponding to the control structures and functions for each of the features included in the integration package, such as connectors, services, processors, control flows, and modifiers, but is not limited thereto, and various functions may be implemented as graphic blocks. For example, a connector may include a "from" block (i.e., From Connector) indicating the start of a route for the integration flow, and a "to" block (i.e., To Connector) indicating external operations, such as calling services, adapters, or saving data, when the integration flow is implemented in the development environment.

[0616] In one embodiment, the From Connector corresponding to the consumer may include at least one of a direct that registers routes within an integrated package and calls routes directly, a timer used when a router executes according to a set period and periodically receives source data from the outside to perform operations, a channel that registers a channel and starts routing when a specific channel is called, a message box that periodically retrieves messages in a processing waiting state and executes a route, or an FTP that checks whether there is a document in a registered FTP service path and starts a route if a document exists.

[0617] In one embodiment, when the message contains information such as sender, receiver, and message type and the message needs to be parsed, the message box of From Connector can be used to add an update field before the route is terminated so that the field value of the message can be changed.

[0618] In one embodiment, the To Connector corresponding to the producer may include at least one of a direct that calls another route within the same integration package, a channel that calls a specific channel, a message box that stores the contents of an exchange body, a channel that calls another channel within the workspace, or an FTP that transfers a document to a registered FTP service.

[0619] In one embodiment, the message box of the To Connector may include a user field function. In this case, desired information within the integration flow may be stored in the user field, and a search may be performed through it. In one embodiment, the user field may be added to the exchange header before saving the document to the message box. For example, the user field may be added because the agent channel is distinguished through the user field (e.g., channelId) when the agent receives the document.

[0620] When a document is saved to a message box in an integrated flow, a search can be performed based on additional information such as a Control Number.

[0621] Services can provide access to services for the integration flow or provide current ControlNumber and memory cache services. Processors can define the processing of messages on the integration flow. Control flows can provide loops, branch processing, etc., on the integration flow. Modifiers can provide functions such as getting and setting values ​​of an exchange.

[0622] However, the functions included in this drawing are merely examples, and it goes without saying that other functions may be included.

[0623] In one embodiment, the application service provision method may provide a user interface including a development tool palette and a development GUI code area. Within the user interface, the user can select a graphic block included in the development tool palette and then drag and drop it into the development GUI code area.

[0624] For example, when an application service provider receives an input signal from a client (310) via a user interface to select a graphic block of a first function (e.g., a "from" block) and then drag and drop it into a development GUI code area, the graphic block of the first function can be output in the development GUI code area. At this time, the drag and drop input signal is merely an example and may include other pre-configured input signals received from the client (310).

[0625] Here, the "from" block is a block that sequentially includes other blocks and must be the top-level block of the integration flow. In other words, the "from" block corresponds to the block containing the beginning and end of the integration flow.

[0626] Subsequently, when the user interface receives an input signal from the user in which the user selects a graphic block of the second function (e.g., a "switch" block) and drags and drops it into the development GUI code area, the graphic block of the second function can be output in the development GUI code area. At this time, the development GUI code area can be configured to automatically include the second function within the first function.

[0627] Subsequently, when the user interface receives an input signal from the user to select a graphic block of a third function (e.g., a "case" block) and drag and drop it into the development GUI code area, the graphic block of the third function can be output in the development GUI code area. At this time, the development GUI code area can be configured to automatically include the third function within the second function.

[0628] In addition, the development GUI code area can display the input fields of parameters included in the graphic blocks of each function as they are. Referring to the aforementioned "from" block, the "from" block in the developer tool palette is a block that defines the start of a route and must specify the object to retrieve data from. Accordingly, the "from" block can be displayed in the development GUI code area as well, while displaying the input fields of parameters as they are.

[0629] Subsequently, the user can directly enter parameters into the input fields of the "from" block. For example, the user can enter the variable name "MessageBox:AA_IN" into the "from" block. That is, the application service provider can receive input signals for parameters of the graphic block output to the development GUI code area through the user interface. Accordingly, the development code can retrieve data from MessageBox AA_IN.

[0630] As such, the user interface for integrated package development of the present invention can provide visual assistance to the user in forming code structures in the development GUI code area by utilizing graphic blocks included in the development tool palette. This offers the advantage of allowing the user to define the integration flow relatively easily, even if they are not familiar with development scripts.

[0631] In addition, according to the present invention, items of the developed integrated flow can be distributed after packaging and converted into a program based on an open source framework at runtime by a pre-stored interpreter to generate an executable integrated package.

[0633] FIG. 37 is a drawing disclosing an example of providing a user interface for developing an integrated flow that performs mapping according to an embodiment.

[0634] An embodiment of the present invention describes an example of developing an integrated flow for performing mapping based on a stored mapping program. In particular, the present drawing shows a user interface for setting information regarding "toBlock" among the input / output (From connect / To connector) coding elements of a route.

[0635] That is, the user of the client (310) can develop an integrated flow using a connector by using the user interface of the present invention, and at this time, can set variable parameters for "".

[0636] For example, the user can set the mapping file for "toBlock" and set the sourceType and targetType.

[0637] Taking this diagram as an example, it explains the process in which a channel named ame / AME_ADAPTER calls an adapter that performs mapping.

[0638] mappingFile represents a mapping program file stored through the above-described embodiment, sourceType represents the type of source document data (e.g., EDI, XML, JSON), and targetType represents the type of target document data.

[0639] In one embodiment, when mapping is actually performed, the data (body data) in the integration flow is converted from the source type to the target type. That is, if the type of the source document data was EDI, the type of the target document data can be converted to JSON through the mapping program.

[0641] Web EDI services allow customers who do not have an EDI system to use a web system to automate tasks such as inter-company ordering, order acceptance, billing, and delivery information through EDI services with partner companies.

[0642] In other words, while web EDI service systems play a crucial role in supply chain management, difficulties can arise if the diverse systems of multiple manufacturers cannot be integrated. In particular, since traditional EDI systems are optimized for specific large manufacturers, suppliers delivering to various manufacturers face the burden of having to manually process documents tailored to each different system.

[0643] To this end, the present invention aims to solve this problem by providing a web EDI service.

[0645] FIG. 38 is a diagram disclosing an example of providing a web EDI service using a message box according to an embodiment.

[0646] According to an embodiment, a web EDI service user (157) can use the web EDI service (156). The web EDI service of the present invention can be provided in connection with the message box (2110) of the application service manager described above.

[0647] In one embodiment, a web EDI service user (157) can upload an Excel file, etc. to a draft document on the web EDI service (156). The uploaded Excel file, etc. can be sent to a specific message box (2110), undergo a verification and conversion process, and then transmitted to a counterparty. Here, the counterparty may be a partner system of the web EDI service user.

[0648] In addition, the web EDI service (156) of the present invention can support an EDI viewer, an editor, and an EDI form designer for each document type. Accordingly, corporate users can develop EDI form templates through the EDI viewer and editor, and developers can develop EDI form templates through the EDI form designer. At this time, the web EDI service (156) of the present invention can provide basic templates such as Forecast, ASN, and Invoice for each standard.

[0649] In addition, the web EDI service (156) of the present invention can simplify order processing and tracking by effectively managing customer-specific product codes by mapping customer-specific buyer item codes and seller item codes, and can maintain consistent data related to the transportation and packaging of goods within the supply chain by managing customer-specific master codes (customer-specific carrier code, packaging type, etc.). At this time, the master code can be referenced in the viewer and editor and can be managed through a separate management screen. This will be described later.

[0650] Below, we will examine in detail the individual features of the web EDI service (156) provided by the present invention.

[0651] Through this, it can provide various benefits such as time savings and error reduction, efficient supply chain management, cost reduction, strengthened relationships with customers and partners, and enhanced compliance and security.

[0653] FIG. 39 is a diagram disclosing an example of providing a web EDI service using a message box according to an embodiment.

[0654] The present drawing illustrates an embodiment of providing a web EDI service (156) to a web EDI user (157). To this end, the present invention can map an EDI document (e.g., X.12 or EDIFACT) of a message box (2110) through a mapping program schema to output an XML (TXT file) document and then output it on the web EDI service (156).

[0655] More specifically, the web EDI service (156) does not convert the EDI document directly into an Excel file, but converts it into an XML document and then converts it into an Excel file through a rendering process using a rendering script (groovy).

[0656] In particular, since directly inputting an EDI document as input data into a rendering script used in the rendering process (as described above for groovy) makes document structure and programming difficult, an XML document is used as input data for the rendering script. To this end, the EDI document of the message box (2110) can be output as an XML document and then used as input data for the rendering process.

[0657] In one embodiment, the web EDI service (156) may output an XML document (TXT file), which is the data before conversion, in a popup format if the rendering process fails. Through this, the web EDI user (157) can track where and how the conversion went wrong through the XML document (TXT file). Further details regarding this will be described later.

[0658] Afterward, the web EDI service (156) allows the web EDI user (157) to view or download an Excel file, which is the output data of the rendering process. At this time, it goes without saying that the Excel file can be a file with a different extension, such as a PDF file or an HTML (web) file.

[0660] FIG. 40 is a drawing illustrating an example of a platform interface according to an embodiment.

[0661] As described above, the application service providing device / method of the present invention can provide various application services.

[0662] At this time, when a client accesses the system initiated by the platform, the platform may provide at least one user interface menu.

[0663] For example, the first user interface menu may include user interface menus related to the user-dedicated workspace (e.g., user-dedicated workspace, message box, file transfer history with partner, message sent to mobile terminal (SMS), and options for information on the corresponding standard mapping if the information exchange is related to EDI).

[0664] As another example, the second user interface menu may correspond to the Web EDI service (156) menu. Accordingly, the Web EDI user can access (log in to) the system disclosed in the present invention and use the Web EDI service (156).

[0666] FIG. 41 is a drawing illustrating an example of a user interface of a web EDI service according to an embodiment.

[0667] When a client accesses the system that is initiated, the platform may provide a user interface menu for the web EDI service (156).

[0668] For example, the platform may provide options for the Inbox document service (158), draft document service (159), and sent document service (160) menus.

[0669] The inbox document service (158) is a service for a client connected to the platform to view received documents, the draft document service (159) is a service for uploading and converting documents (e.g., from an Excel file to an XML file) before transmission and then actually making a transmission request, and the cent document service (160) is a service for viewing transmitted documents. Through the platform, the client can check the Excel file before conversion and the original XML file (TXT format) after conversion through the inbox document service (158), the draft document service (159), and the cent document service (160). Further details regarding this will be described later.

[0670] In addition, the platform may provide a user information management menu (163) for users accessing the web EDI service (156). The user information management menu (163) may provide user information. Here, user information may include personal information such as user ID, customer ID, username, mobile phone number, email address, job title, assigned duties, and time zone. Additionally, through the user information management menu (163), the client may change personal information or change the login password that allows access to the web EDI service (156).

[0672] FIG. 42 is a drawing illustrating an example of a user interface of an inbox document service according to an embodiment.

[0673] The present drawing describes an embodiment in which the platform provides a user interface for the inbox document service (158) as the client selects the inbox document service (158) menu provided by the platform.

[0674] More specifically, the inbox document service (158) can output information about a document received by a client. In one embodiment, information about the received document may include a create time, message type, trading partner, status, and a view / download menu. Here, the message type may represent a standard document number. For example, a 3-digit number may be used for the ANSI X.12 standard, and a 6-digit character may be used for EDIFACT. Details regarding this are announced in the standard document. Additionally, the status of the received document provided by the inbox document service (158) may be displayed as delivered to the recipient (Delivered, after conversion) or to be delivered (To be delivered, before conversion).

[0675] Additionally, the inbox document service (158) may provide viewing or download options for the received document. At this time, the viewing or download options for the received document may be provided as TXT files, HTML files, XLS files, PDF files, etc. In particular, the inbox document service (158) is characterized by providing the original document in a popup form in the case of a TXT file, providing an HTML rendering popup form in the case of an HTML file, providing an Excel file download form in the case of an XLS file, and providing a PDF file download form in the case of a PDF file. However, it goes without saying that the viewing and download functions can be provided as a popup form for all TXT files, HTML files, XLS files, and PDF files. Accordingly, the client can view or download the original document and the converted document after performing the rendering process through the inbox document service (158).

[0676] Additionally, the inbox document service (158) can search for received documents by filtering them based on at least one of creation time, transaction partner, status, message type, and message ID.

[0678] FIG. 43 is a drawing illustrating another example of a user interface of an inbox document service according to an embodiment.

[0679] This drawing shows a pop-up window (164) that is displayed when a client selects, for example, the view menu of an HTML file from the menu provided by the inbox document service (158) provided by the platform. The inbox document service (158) can provide a preview window for a document received on a web screen as a pop-up. Although an HTML file was used as an example for this explanation, it is obvious that a TXT file can also be provided through the pop-up window (164).

[0680] In another embodiment, if an error occurs during the rendering process of an HTML file, an error log may be output instead of a popup window. Through this, the client can not only check the data before conversion even if an error occurs during the rendering process, but also track where and how the conversion went wrong. Further details regarding this will be described later.

[0682] FIG. 44 is a drawing illustrating an example of a user interface of a draft document service according to an embodiment.

[0683] The present drawing describes an embodiment in which the platform provides a user interface for the draft document service (159) as the client selects the draft document service (159) menu provided by the platform.

[0684] More specifically, through the draft document service (159), the client can upload and convert the document and then actually perform a transmission request.

[0685] In one embodiment, the draft document service (159) may provide new draft document information through a creation menu (165). The draft document information may include a Draft ID, Create Time, Message Type, Title, File Name, Status, Message ID, and Action Menu. Here, the status of the draft document provided by the draft document service (159) may be indicated as the draft document created, uploaded, verified, and sent.

[0686] Additionally, the draft document service (159) can search for generated draft documents by filtering based on at least one of the creation time, file name, title, status, message type, and draft ID.

[0687] In one embodiment, the draft document service (159) may provide various action menus based on each state. In one embodiment, the draft document service (159) may provide a document upload menu (166) when the draft document is created. The client can upload a document to the web EDI service through the document upload menu (166). At this time, the client can directly upload an Excel file on the web screen.

[0688] In one embodiment, the draft document service (159) may provide a document verification and conversion menu (167) when a document is uploaded to the draft document. The client can verify and convert the uploaded document through the verification and conversion menu (167).

[0689] In one embodiment, the draft document service (159) may provide a document transmission menu (168) when a document uploaded to the draft document is verified and converted. The client may transmit the verified and converted document through the document transmission menu (168). That is, the Web EDI user may transmit the uploaded document through the Web EDI service. At this time, the Web EDI service may send the document requested for transmission to a specific message box and deliver it to the Web EDI user's partner system through a conversion process and a transmission process. At this time, the Web EDI user's partner system may correspond to, for example, an ERP system.

[0690] When a document is transmitted, the transmitted message ID may be displayed, and the draft document service (159) may provide an original document download menu (169).

[0691] Below, we will look at the specific functions provided by the draft document service (159).

[0693] FIG. 45 is a drawing illustrating an example of a user interface of a draft document service according to an embodiment.

[0694] This drawing shows the user interface provided by the platform as the client selects the creation menu of the draft document service (159) provided by the platform.

[0695] When a client selects the draft document creation menu, the draft document service (159) may provide a message type, title, example template (170), immediate verification option (178), and upload file attachment option (179). When a client selects the example template (170), the draft document service (159) may provide an example Excel template file download. Accordingly, the client can fill out the downloaded Excel template file and then upload the Excel file through the upload file attachment option (179).

[0696] In one embodiment, the draft document service (159) can upload a file, and if the client selects the immediate verification option (178), the verification and conversion process (180) of the uploaded file can be performed automatically as the draft document is created.

[0697] In another embodiment, if the client does not select the immediate verification option (178), the draft document service (159) may only generate a draft document and not verify the document (181). In this case, the draft document service (159) may verify the document after generating the draft document. This will be described later.

[0699] FIG. 46 is a drawing illustrating an example of a user interface of a draft document according to an embodiment.

[0700] This drawing illustrates an embodiment in which a client creates a draft document without selecting the immediate verification option (178) of the draft document service (159) provided by the platform. First, the draft document service (159) may provide an example template (170) and an upload file attachment option (179). After the draft document is created, the draft document service (159) may provide a draft ID and the current status at each stage.

[0701] After the uploaded file is attached, the draft document service (159) can provide a file verification / conversion menu (182) and a transmission menu (183). Additionally, while each action is being processed, the draft document service (159) can output a loading spinner.

[0702] Afterward, the draft document service (159) can send the file to a specific inbox of the message box when the file verification / conversion is complete. At this time, if the file verification / conversion fails, it may display an error log and not send the file.

[0703] In addition, each diagram of this drawing may be output sequentially or individually according to each action (draft document creation, upload, verification, transmission, etc.).

[0705] FIG. 47 is a drawing illustrating an example of a user interface of a cent document according to an embodiment.

[0706] This drawing describes an embodiment in which the platform provides a user interface for the cent document service (160) as the client selects the cent document service (160) menu provided by the platform.

[0707] More specifically, the client can check the transmitted document through the cent document service (160). In one embodiment, the cent document service (160) can output information about the transmitted document. Here, the information about the transmitted document may include a message ID, creation time, message type, transaction partner, status, and a message payload view menu. At this time, the status may include the status of the transmitted document being delivered, failed, and waiting.

[0708] In one embodiment, when a client selects the message payload view menu (184), the cent document service (160) may output the message payload to a pop-up window (185). In addition, although not illustrated in the drawing, the cent document service (160) may provide a download of the message payload.

[0709] Additionally, the cent document service (160) can also search for transmitted documents by filtering them based on at least one of creation time, transaction partner, status, message type and message ID.

[0711] FIG. 48 is a flowchart illustrating an application service provision method that provides a web EDI service according to an embodiment.

[0712] A processor of a virtualized computing system within a platform providing an isolated workspace of an embodiment of the present invention can receive a web EDI service request from a client using the workspace (S901).

[0713] In this case, the Web EDI service can be provided in connection with the Application Service Manager's message box. Web EDI service users can upload files other than standard EDI documents using the draft document service provided by the Web EDI service. The uploaded files, etc., are transmitted to the message box, undergo a verification and conversion process, and can then be sent to the Web EDI service user's partner system.

[0714] The embodiment may provide at least one of an inbox document service, a draft document service, and a sent document service through a web EDI service (S903).

[0715] Here, the inbox document service is a service for a client connected to the platform to view a received document, the draft document service is a service that performs the upload, verification, and conversion processes of a document before transmission and then actually performs the transmission request, and the cent document service corresponds to a service for viewing or downloading a transmitted document.

[0717] FIG. 49 is a drawing showing the operation of a scrap adapter according to an embodiment.

[0718] According to an embodiment, the instance system (1000) of the present invention may provide a scrap adapter (1400) to a client (300). At this time, the client (300) using the instance system (1000) of the present invention may be, for example, a third-party logistics company.

[0719] The scrap adapter (1400) can use various services by utilizing the application service manager (2100) of the present invention. More specifically, the platform may provide at least one of a configuration service interface that provides access to configuration settings necessary for the scrap adapter (1400) to use the framework, a task service interface that provides functions related to task processing, a channel access service interface that provides access to a communication channel, a message box access service interface that provides access to a message box, and a configuration storage service interface.

[0720] That is, the scrap adapter (1400) enables the client (300) to automatically collect data from a partner through services such as a message box (2110) service and a configuration repository. At this time, the data collected by the client (300) from the partner may generally include at least one of the partner's order data and shipping data. Here, if the client is a logistics company, the partner corresponds to a retailer, which is the target of the logistics company's order collection. Further details regarding this will be described later.

[0721] If the application service manager (2100) provided by the present invention is not used, the client (300) faces the difficulty of having to individually develop all the code included in the scrap adapter (1400). When the scrap adapter (1400) of the present invention is used, the client (300) can use the various services of the application service manager (2100) that the scrap adapter (1400) can already use, so it can automatically collect data from the distributor by simply inputting the specific configuration information described below. In addition, other clients (300A, 300B) using the first distributor have the advantage of being able to use the scrap adapter (1400) of the client (300) that was previously developed. Of course, in the case of client A (300A) and client B (300B), configuration information for using the scrap adapter (1400) must be input through a separate agent.

[0722] In order for the scrap adapter (1400) to automatically collect data from distributors, the client (300) can register account and password information, company information, interval / cron information, and transmission channel information for the scrap adapter (1400) through the agent (350). Here, the company information represents supplier information, and the interval information represents the data collection execution cycle of the scrap adapter.

[0723] Generally, even if a distributor links data to an ERP system, it is difficult for a client using the ERP system to determine whether data has been collected. On the other hand, the scrap adapter (1400) of the present invention can determine whether the first data is data that has already been collected when collecting data from a distributor. More specifically, the scrap adapter (1400) can avoid collecting the first data again by marking an index on the first data that has been collected once from the distributor. That is, if the first data is data that has a record of being collected once, the scrap adapter (1400) can be configured to collect the second data without collecting the first data again.

[0724] In one embodiment, the scrap adapter (1400) can transmit data collected from a distributor to the inbox slot of the message box (2110) using the message box transmission module (1401). At this time, the message box transmission module (1401) can transmit the distributor's data to the inbox slot of the message box (2110) as a JSON file or an XML file.

[0726] FIG. 50 is a drawing illustrating an example of a user utilizing a scrap adapter according to an embodiment.

[0727] This drawing is a drawing for explaining the process of an actual user using the web scrap adapter (1400) of the present invention.

[0728] More specifically, suppliers 1 to 3 can produce goods and deliver them to the client's (300) warehouse. Here, the client (300) may be an example of a third-party logistics company that owns a warehouse.

[0729] Retail stores a1 and a2 can order goods from distributor A (the aforementioned partner corresponds thereto) via a web service. In one embodiment, the web scrap adapter (1400) of the present invention can collect order data from retail store a1 and order data from retail store a2 received by distributor A. Likewise, the web scrap adapter (1400) can collect order data from retail store b1 and order data from retail store b2 received by distributor B. A client (300) using the web scrap adapter (1400) can directly deliver goods held in a warehouse to the retail stores based on the order data from retail stores a1 and a2 and retail stores b1 and b2 collected through the scrap adapter (1400).

[0730] In particular, although the web scrap adapter (1400) of the present invention was developed for a client (300) to collect order data from distributor A and distributor B, as described above, other application services within the platform can be used for the development of the web scrap adapter (1400), so that other clients (e.g., client A or client B) can use the web scrap adapter (1400) as is without additional development to collect order data from distributor A or distributor B.

[0732] FIG. 51 is a drawing illustrating an example of a user interface of a platform according to an embodiment.

[0733] This drawing illustrates an interface provided by a platform when a client connects to a platform according to an embodiment that provides application services. When a client connects to a system that is initiated, the platform may provide a user interface menu related to a user-dedicated workspace. For this, refer to the above-described embodiment.

[0734] In this drawing, the client can access a user interface menu related to a client-only workspace on the platform to use the scrap adapter described above.

[0735] The platform of the present invention can provide the client with a scrap adapter user interface (186) corresponding to a scrap adapter among the adapters installed in the client-only workspace.

[0736] The scrap adapter user interface (186) can manage suppliers to scrap. For example, if the client of the scrap adapter is a logistics company, in order for the logistics company to collect order data from a distributor, the scrap adapter must collect information on at least one supplier that supplies goods to the distributor.

[0737] In one embodiment, the scrap adapter user interface (186) may output a list of at least one supplier (187) of a distributor. More specifically, the supplier list (187) may include information about at least one supplier that supplies goods to the distributor. Information about the supplier may include a group ID, a user ID, a schedule type, a schedule representation, an inbox slot, and an active status. Here, the group ID represents the ID of the supplier, and the user ID represents the user ID of the supplier. The schedule type may be selected as a method for setting the cycle for the scrap adapter to collect data, for example, an Interval method or a CRON method. Here, the Interval method is a method of repeating the task at regular time intervals, and the CRON method is a method of setting a complex and specific time schedule.

[0738] The client can input information about the supplier to be scrapped into the scrap adapter user interface (186), and the scrap adapter can scrape data based on the input information and then deliver it to the inbox slot of the message box of the present invention.

[0740] FIG. 52 is a drawing illustrating an example of a user interface of a platform according to an embodiment.

[0741] This drawing illustrates a menu for managing suppliers to scrap within the scrap adapter user interface (186) for the client to use the scrap adapter described above.

[0742] In the present drawing, the supplier management menu may include supplier information (188), such as a scrap ID, supplier name, group ID, and user ID, and may include scrap information (189) and other information (190). Here, the scrap information (189) may provide an initial date for starting the scrap, a retry count when the scrap fails, a retry interval before retrying when the scrap fails, a schedule type, and a schedule representation. The other information (190) may include message box inbox slot information, buyer code (e.g., distributor name), delivery information, order information, supplier information, receipt confirmation status, and order classification information.

[0743] When a client enters and saves information in the supplier management menu, the platform of the present invention can automatically collect data based on the information entered by the client using a scrap adapter.

[0745] FIG. 53 is a drawing disclosing a data collection method according to another embodiment.

[0746] This drawing illustrates an example of data substantially collected by the scrap adapter of the present invention. This drawing illustrates a method by which client A (300A) directly checks order data for at least one distributor on the web.

[0747] When using the scrap adapter of the present invention, the scrap adapter automatically collects order data on the web as shown in this drawing.

[0748] For example, Client A (300A) can collect information about an order data list (191) for at least one distributor, and can collect detailed information about the first to nth order data included in the order data list (191) by individually selecting the first to nth order data. If the scrap adapter of the present invention is not used, Client A (300A) must download the order data list (191) directly on a web screen or download detailed information about the order data by individually selecting the first to nth order data included in the order data list (191). However, if the scrap adapter of the present invention is used, the scrap adapter can automatically collect the order data for Client A (300A)'s distributor.

[0749] In addition, the scrap adapter can set filter conditions (e.g., scrap only specific order locations, 192) through the other information (190) field of FIG. 51. When the scrap adapter sets filter conditions (190 of FIG. 51), it has the same effect as collecting the order data list (191) according to the filter conditions (192) of the present drawing.

[0751] FIG. 54 is a drawing showing the operation of a scrap adapter according to an embodiment.

[0752] A processor of a virtualized computing system within a platform that provides an isolated workspace can receive scrap adapter configuration information from a client using the workspace (S905).

[0753] In one embodiment, the platform may provide an Application Programming Interface (API) necessary for a scrap adapter to use the framework. Here, the API may include at least one of a Configuration Service Interface providing access to configuration settings, a Task Service Interface providing functions related to task processing, a Channel Access Service Interface providing access to a communication channel, a Message Box Access Service Interface providing access to a message box, and a Configuration Store Service Interface.

[0754] In one embodiment, the platform may receive scrap adapter configuration information from a client. Here, the scrap adapter configuration information may include account and password information, company information, cycle information, and transmission channel information. For this, refer to the details described in FIG. 49.

[0755] Data of the partner set by the client can be collected based on the scrap adapter setting information (S907). At this time, an example of the scrap adapter collecting data of the client's partner based on the setting information entered by the client is described in detail in FIG. 52.

[0756] The collected data can be stored in the inbox slot of the message box within the platform (S909).

[0757] For this, please refer to the details described in Fig. 49. Explanation of the symbols

[0759] 110, 120, 130, 310: Client 200, 320: Partner 300: Client or Partner 350: Agent 351: Agent Control Processor 353: Transmission / Reception Configuration Processing Unit 357: Transmitter / Receiver 1000: Instance system 1100: Coordinator 1110, 1120, 1300, 3110, 3210: Node 1330, 1115, 3115, 3215: Configuration storage 1350: Agent Adapter 1351: Agent Control Unit 1352: Transmission / Reception Settings 1353: Transmission and reception processing unit 1370: Mapping Adapter 1380: Integrated Package 1390: EDI Adapter 1500, 1510, 1520, 1530: Workspace 1610: API 1700: Framework Layer 1800: Virtualization layer 1900: Resource layer 2000: Manager System 2100: Application Service Manager 2110: Message Box 3000: Development Workspace 4000: Interface Governance Platform 4100: Governance API< / file> < / t>

Claims

Claim 1 A method for providing an application service, wherein a processor of a virtualized computing system within a platform providing an isolated workspace receives scrap adapter configuration information from a client using the workspace, wherein the scrap adapter configuration information includes account and password information, company information, cycle information, and transmission channel information; a step of collecting data of a partner set by the client based on the scrap adapter configuration information; and a step of storing the collected data in an inbox slot of a message box within the platform, wherein the step of collecting the partner data includes marking an index on the first data collected by the scrap adapter from the partner, and subsequently collecting a second data without collecting the data marked with the index again during data collection, and the step of storing the collected data in an inbox slot of the message box includes transmitting the collected data to the inbox slot of the message box as a JSON file or an XML file. Claim 2 A method for providing application services according to claim 1, wherein the platform provides an Application Programming Interface (API) necessary for the scrap adapter to use the framework, wherein the API includes at least one of a Configuration Service Interface providing access to configuration settings, a Task Service Interface providing functions related to task processing, a Channel Access Service Interface providing access to a communication channel, a Message Box Access Service Interface providing access to a message box, and a configuration repository Service Interface. Claim 3 An application service providing device comprising: a storage medium for storing data; and a virtualized computing system within a platform that provides an isolated workspace, wherein the virtualized computing system includes a processor for processing the data, wherein the processor receives scrap adapter configuration information from a client using the workspace, and the scrap adapter configuration information includes account and password information, company information, cycle information, and transmission channel information; wherein, based on the scrap adapter configuration information, a scrap adapter installed on the platform collects data of a partner set by the client and stores the collected data in an inbox slot of a message box within the platform, wherein the scrap adapter marks an index on the first data collected from the partner, and subsequently, when collecting data, does not collect the data marked with the index again but collects a second data, and wherein the collected data is transmitted to the inbox slot of the message box as a JSON file or an XML file. Claim 4 In claim 3, the platform provides an Application Programming Interface (API) necessary for the scrap adapter to use the framework, and the API includes at least one of a Configuration Service Interface providing access to configuration settings, a Task Service Interface providing functions related to task processing, a Channel Access Service Interface providing access to a communication channel, a Message Box Access Service Interface providing access to a message box, and a configuration repository Service Interface. Claim 5 A computer-readable recording medium storing an application service provider program, characterized in that a processor of a virtualized computing system within a platform providing an isolated workspace receives scrap adapter configuration information from a client using said workspace, wherein the scrap adapter configuration information includes account and password information, company information, cycle information, and transmission channel information; based on said scrap adapter configuration information, a scrap adapter installed on said platform collects data of a partner set by said client; and performs the step of storing said collected data in an inbox slot of a message box within said platform, wherein the step of collecting said partner data includes marking an index on first data collected by said scrap adapter from said partner, and subsequently, when collecting data, collecting second data without collecting the data marked with said index again, and the step of storing said collected data in an inbox slot of said message box includes the step of transmitting said collected data to the inbox slot of said message box as a JSON file or an XML file.

Images