Device for providing application service, method for providing application service, and storage medium storing computer-executable program for providing application service

Abstract

An embodiment of the present invention provides a method for providing an application service in a computing system for managing a platform that provides a client with isolated workspaces in which an application package is executed, the method comprising the steps in which: a channel request for transmitting and receiving information is received from a client; and the client provides a platform service for converting the application package in the workspaces.

Description

Application service providing device, application service providing method, and storage medium storing a program executable by a computer providing application service

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

[0002]

[0003] In transactions between companies or between companies and individuals, information related to the transaction or documents containing that information are exchanged.

[0004] However, the exchange of documents, the format or specifications of the information to be included in the documents, may vary from company to company, and various types of transactions may require different formats of documents, internal request contents, or methods of description, so various software programs have been developed.

[0005] Such software can help businesses enter and exchange information necessary for transactions in standardized formats, such as through electronic document exchange (EDO). As this EDO becomes more widespread, standardized methods will be established, allowing transacting parties to convert these documents into standardized electronic documents and exchange, store, and process them on their computers, saving time and effort.

[0006] However, the software that generates these standardized electronic documents often has the inconvenience of having to be individually changed depending on the parties to the transaction, the nature of the transaction, and the format and content of the transaction.

[0007] For newcomers to the market, it can be difficult to prepare standardized forms and formats required by existing transaction parties. The market's complex transaction patterns and requirements often make it difficult to understand or follow these standardized transaction formats, making it difficult to facilitate transactions.

[0008] Additionally, when the parties to a transaction use incompatible software or have separate software for incompatible systems, there are technical inconveniences such as having to develop software for the transaction or having software tailored to the system.

[0009] Even if application services are provided with the same software image, there are difficulties in providing efficient services, such as having 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 to operate 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 amount of data.

[0011]

[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 program executable by a computer that provides an application service to support non-stop scale-out through distributed package replication and distributed channel communication.

[0013]

[0014] One embodiment of the present invention provides a method for providing an application service, comprising: a computing system managing a platform that provides a client with an isolated workspace in which an application package is executed; receiving a channel request for transmitting and receiving information from the client; and providing the client with a platform service for transforming the application package in the workspace; wherein the step of providing the platform service comprises: providing the client with a user interface including a development tool palette and a GUI block area; generating a first function block corresponding to a first graphic block upon receiving a signal from the client for selecting a first graphic block included in the development tool palette by a user; and outputting the generated first function block to the GUI block area.

[0015] The step of providing the platform service includes: receiving a service request for the application package from the client; performing authentication of the requested application package based on authentication information included in a software bundle associated with the workspace; and providing a service for the received application package based on a result of the authentication.

[0016] The step of providing the platform service includes: a step of setting channel information to be provided to a first computing system external to the platform based on the platform providing the isolated workspace; a step of receiving data collected in relation to the first computing system according to the set channel information; and a step of providing the collected data to a second computing system using the isolated workspace.

[0017] The step of providing the platform service includes the steps of: providing the client with an application service manager that develops an adapter package; providing the client with a first workspace for testing the developed adapter package; and providing the client with a second workspace for executing the developed adapter package.

[0018] The step of providing the platform service includes: receiving a request for uploading the application package to the app store from the client; approving the upload of the application package to the app store based on predefined approval judgment conditions for the application package according to the upload request; and providing the approved application package in the app store.

[0019] The step of providing the platform service includes the steps of: receiving a message from the client including the client's authentication key for the client's internal system; identifying the client based on the authentication key; and providing a service based on the message to the identified client.

[0020] The step of providing the platform service includes the steps of: receiving source document data having a first data format from the client; converting the source document data having the first data format into target document data having a second data format; and transmitting the target document data having the second data format to a partner.

[0021] The step of providing the platform service includes the steps of providing the client with a user interface including a development tool for an integration flow for an integration package; receiving an input signal for the development tool for the integration flow from the client; generating the integration package corresponding to the input signal; and distributing the generated integration package to the client's workspace.

[0022] One embodiment of the present invention provides an application service providing device, comprising: a database for storing data; and a processor for processing the data, wherein the processor manages a platform that provides a client with an isolated workspace in which an application package is executed, wherein the processor receives a channel request for transmitting and receiving information from the client, provides the client with a user interface including a development tool palette and a GUI block area, and generates a first function block corresponding to the first graphic block upon receiving a signal from the client for selecting a first graphic block included in the development tool palette by a user, and outputs the generated first function block to the GUI block area.

[0023] One embodiment of the present invention provides a computer-executable program for providing an application service, comprising: a computing system managing a platform that provides a client with an isolated workspace in which an application package is executed; receiving a channel request for transmitting and receiving information from the client; and providing a platform service for the client to transform the application package in the workspace; wherein the step of providing the platform service comprises: providing the client with a user interface including a development tool palette and a GUI block area; generating a first function block corresponding to a first graphic block upon receiving a signal from the client for selecting a first graphic block included in the development tool palette by a user; and outputting the generated first function block to the GUI block area; and a storage medium storing the computer-executable program for providing the application service.

[0024]

[0025] According to the disclosed embodiment, technical inconveniences for transactions can be resolved and transactions can be made more active.

[0026] According to the disclosed embodiment, it is possible to technically activate market transactions using software even when a standardized form for existing transactions is not available or there are complex transaction requirements.

[0027] According to the disclosed embodiment, a convenient transaction system can be provided even when the transaction parties use incompatible software or have separate software in incompatible systems.

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

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

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

[0031]

[0032] Figure 1 is a flowchart disclosing an example of a method for providing an application service according to an embodiment.

[0033] FIG. 2 is a drawing showing an example of providing application services to a client through a workspace among the disclosed embodiments.

[0034] Figure 3 is a drawing showing an example of distributing packages to each node in an example of an application service device disclosed.

[0035] Figure 4 is a conceptual diagram disclosing layer-by-layer elements for providing application services according to an embodiment.

[0036] FIG. 5 is a diagram disclosing a concept of an application service providing device according to an embodiment establishing a channel between an instance and a client or partner.

[0037] FIG. 6 is a drawing 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.

[0038] FIG. 7 is a diagram showing an example of setting up a distributed channel and providing a service according to an embodiment.

[0039] FIG. 8 is a drawing disclosing an example of managing setting information of a package installed according to an embodiment.

[0040] FIG. 9 is a diagram showing an example of managing and using a package according to a workspace of an embodiment of the disclosure.

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

[0042] FIG. 11 is a drawing disclosing an example of providing an application service using an integrated package according to an embodiment.

[0043] FIG. 12 is a drawing showing an example of an interface of a platform according to an example of providing an application service disclosed.

[0044] FIG. 13 is a drawing showing another example of the interface of a platform according to an example of providing an application service disclosed.

[0045] FIG. 14 is a drawing disclosing an example of a framework that allows an application service providing device according to an embodiment to integrate different systems.

[0046] Figure 15 is a drawing showing an example of graphically coding a connector among the integration flow functions when developing an integration flow based on an embodiment.

[0047] Figure 16 is a drawing showing an example of graphically coding a service among the integration flow functions when developing an integration flow based on an embodiment.

[0048] Figure 17 is a drawing showing an example of graphically coding a processor among the integration flow functions when developing an integration flow based on an embodiment.

[0049] Figure 18 is a drawing showing an example of graphic-based coding of the control flow among the integration flow functions when developing an integration flow based on an embodiment.

[0050] Figure 19 is a drawing showing an example of graphically coding a modifier among the integration flow functions when developing an integration flow based on an embodiment.

[0051] FIG. 20 is a diagram disclosing an example of providing a unique workspace isolated for each client according to an embodiment.

[0052] FIG. 21 is a flowchart illustrating an example of providing a package to a client from an isolated workspace according to an embodiment.

[0053] Figure 22 is a drawing illustrating an interface of an agent when an agent provided on a platform of an instance system according to an embodiment is executed.

[0054] FIG. 23 is a drawing illustrating an example of an interface of an agent adapter provided on a platform of an instance system according to an embodiment.

[0055] FIG. 24 is a drawing illustrating another example of an interface of an agent adapter provided on a platform of an instance system according to an embodiment.

[0056] Figure 25 is a diagram showing an example of an agent adapter of a platform of an instance system according to an embodiment setting up a transmission and reception channel.

[0057] Figure 26 is a drawing showing an example of transmitting EDI data, which is transaction information, using a platform of an instance system according to an embodiment.

[0058] FIG. 27 is a diagram showing an example of a platform of an instance system according to an embodiment providing data to a client system.

[0059] FIG. 28 is a drawing showing an example of a platform of an instance system according to an embodiment receiving data from a partner system.

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

[0061] Figure 30 is a drawing disclosing an example of an adapter package.

[0062] FIG. 31 is a diagram disclosing an example of running an adapter in a workspace according to an embodiment.

[0063] Figure 32 is a drawing disclosing an example of an adapter using a framework according to an embodiment.

[0064] Figure 33 is a drawing disclosing an example of a service provided by an adapter package according to an embodiment.

[0065] Figure 34 is a drawing disclosing an example of an adapter developed in a workspace according to an embodiment.

[0066] FIG. 35 is a drawing disclosing an example of a framework for developing an adapter package according to an embodiment.

[0067] FIG. 36 is a drawing disclosing an example of an application service providing device according to an embodiment providing an application package on an app store platform.

[0068] Figure 37 is a flowchart disclosing another embodiment of a method for providing application services according to an embodiment.

[0069] Figure 38 is a flowchart disclosing another embodiment of a method for providing application services according to an embodiment.

[0070] FIG. 39 is a drawing disclosing an example of an application service providing device according to an embodiment providing a service for an application package.

[0071] FIG. 40 is a drawing disclosing another example in which an application service providing device according to an embodiment provides a service for an application package.

[0072] Figure 41 is a flowchart disclosing an example of a method for providing application services according to an embodiment.

[0073] Figure 42 is a flowchart disclosing an example of a method for providing an application service according to an embodiment of the present invention.

[0074] Figure 43 is a drawing disclosing an example of an application service providing device converting a data format according to an embodiment.

[0075] FIG. 44 is a drawing disclosing an example of an application service providing device according to an embodiment converting a data format using a schema and a mapping script.

[0076] Figure 45 is a diagram disclosing an example of deserialization and serialization based on a schema according to an embodiment.

[0077] Figure 46 is a drawing disclosing an example of a mapping script according to an embodiment.

[0078] Figure 47 is a flowchart showing an example of a method for providing an application service according to an embodiment of the present invention for converting a data format.

[0079] FIG. 48 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0080] FIG. 49 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0081] FIG. 50 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0082] FIG. 51 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0083] FIG. 52 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0084] FIG. 53 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0085] Figure 54 is a drawing showing an example of a method for providing an application service among the disclosed embodiments.

[0086] FIG. 55 is a drawing disclosing an example of an application service providing device according to an embodiment creating and testing an integrated package.

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

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

[0089] FIG. 58 is a drawing disclosing an example of providing a user interface for designating a development workspace in an embodiment.

[0090] FIG. 59 is a drawing disclosing an example of providing a user interface for integrated flow testing according to an embodiment.

[0091] FIG. 60 is a drawing disclosing an example of a mock data input for an integrated flow test according to an embodiment.

[0092] Figure 61 is a flowchart showing an example of a method for providing an application service according to an embodiment of the present invention for converting a data format.

[0093]

[0094] Below, embodiments that can solve the above problems and resolve technical inconveniences for transactions are disclosed.

[0095] When components of the embodiments are mentioned below, they can all be implemented with optimized hardware or software, unless specifically limited to physical devices.

[0096]

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

[0098] The method for providing an application service according to the disclosed embodiment allows multiple clients to obtain or download applications necessary for transactions or add or change desired functions through the platform.

[0099] The embodiment can receive a channel request for transmitting and receiving information from a client using a virtual isolated workspace (S100).

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

[0101] A client may have workspaces that can receive separate services, but the hardware infrastructure of the systems providing each workspace may be common.

[0102] The system administrator or client can perform remote control and update of the system so that the client can receive the above services, and the system can be equipped with communication functions according to protocols linked to various standards.

[0103] A client can request a channel from the platform through which it can send and receive desired information, and the platform can allow the client to establish a channel.

[0104] Detailed examples of this are disclosed below.

[0105] The embodiment may provide a platform service that enables a client to create, change, save, or otherwise transform an application package in his / her workspace (S200).

[0106] A client may develop an application package or part of a package in a system such as an embodiment, and may trade related applications or software and operate a trade-related business.

[0107] Hereinafter, the term "application package" or "package" refers to a bundle of programs or files, including adapter packages that support protocols or services, resource packages required for program execution, and integrated packages that integrate multiple packages. In the examples below, an application package may also be referred to as a software package.

[0108] The system may provide various means or specialized computer languages ​​that support mappings to various data formats and structures desired by clients. It may also provide applications and related tools to enable clients to modify application packages.

[0109] Detailed examples of this are disclosed below.

[0110] The embodiment can provide a service that controls service scale-out when the client uses an application package or another client receives application services in their workspace (S300). This step can be performed as needed to control scale related to service provision. The client can receive application services or operate the application services without interruption, depending on the provided system.

[0111] Detailed examples of this are disclosed below.

[0112]

[0113] FIG. 2 is a drawing showing an example of providing application services to a client through a workspace among the disclosed embodiments.

[0114] This drawing is a conceptual diagram for explaining workspace and multi-tenancy among embodiments providing the disclosed application service.

[0115] The embodiment may provide a software-as-a-service (SaaS) to the user.

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

[0117] In this drawing, the trading parties are represented as Client 1 (110), Client 2 (120), or Client 3 (130).

[0118] Clients (110, 120, 130) can transmit and receive various information, including business transactions, with their respective partners. In this case, the clients (110, 120, 130) can utilize the application service provision method described above.

[0119] An application service providing device according to an embodiment includes an instance system (1000) that provides an application including software in the SaaS format, and a manager system (2000) that provides an application service through the instance system (1000).

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

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

[0122] The manager system (2000) may include a manager server (2100) that connects and controls the instance system (1000) and a database (2200) that can store transmitted and received information and requirements of clients (110, 120, 130). The functions of the manager system (2000) are described in detail below.

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

[0124] 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).

[0125] In this example, the coordinator (1100), which is node #0, can control the scale of the system by being connected 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).

[0126] For example, connections between nodes can utilize interface protocols such as the HTTP protocol (hereinafter referred to as HTTP / REST) ​​of a RESTful application programming interface (API). A RESTful application programming interface (API) can use HTTP to transmit and receive data between servers.

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

[0128] Similarly, Node #1 can send and receive data with other nodes (Node #0, Node #2, Node #3, and Node #N) based on HTTP / REST.

[0129] The coordinator (1100) can cause the software package to be installed on each node (in this example, the first node (Node #1) to the Nth node (Node #N)) according to a request for software package installation from the manager system (2000).

[0130] Each node can include a framework that allows creation of workspaces regardless of system type, as described below.

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

[0132] Clients (110, 120, 130) may have isolated workspaces (1510, 1520, 1530) and may be provided with, modified or used applications or software packages through the isolated workspaces.

[0133] 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).

[0134] 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).

[0135] 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).

[0136] The manager system (2000) can stably provide each of the isolated workspaces (1510, 1520, 1530) to the clients (110, 120, 130) through the instance system (1000).

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

[0138] Client 1 (110) can transmit 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 channels between the workspace and the coordinator (1100) or between the coordinator (1100) and each node will be described later.

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

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

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

[0142] 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 be virtualized to provide workspaces (1510, 1520, 1530) that are isolated from each other.

[0143] Each of the nodes (Node #1, Node #2, Node #3, Node #N) contains a framework, and can control the download and execution of software packages from a software package repository (not shown) within each framework. This will be described in detail below.

[0144] The software package required for workspace A (1510) used by client 1 (110) can be stored in at least one node among each of the nodes (Node #1, Node #2, Node #3, Node #N).

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

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

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

[0148] In this way, software packages can be distributed and installed across multiple nodes. The coordinator (1100) stores information on which nodes the software package is installed, performs routing for software package requests when necessary, and performs task scheduling functions for the nodes it manages.

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

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

[0151] Nodes serve as worker nodes on which the adapter package or software package described below is installed and executed. In the instance system (1000), worker nodes can be automatically or manually scaled out and expanded as needed under the management of the manager system (2000).

[0152]

[0153] FIG. 3 discloses an example of distributing packages to each node in an example of an application service device disclosed.

[0154] According to an embodiment, software developers can use software images to rapidly develop and deploy applications.

[0155] The framework on each node can run applications and utilize as many of the node's resources as needed to run the applications. If the node is part of a cloud system, the application can run based on cloud resources. If the node is on-premises, the application can run based on on-premises resources. This diagram illustrates the cloud scenario.

[0156] The framework on the nodes included in the instance system can control the cloud / on-premise resources that the nodes contain for virtualization processing of applications and can enable porting of application packages to other nodes.

[0157] An application service provider can create a service-related software package (service app) and store it in a storage device or application repository (registry). For ease of explanation, the application service provided by the application service provider is exemplified as an Electronic Data Interchange (EDI) service, and the software package is exemplified as a software image for the EDI service (EDI service app).

[0158] For example, EDI refers to a method of exchanging information related to commercial transactions by entering it in an agreed-upon standard format and using a standardized transmission and reception method. EDI services can exist in a wide variety of formats, depending on the transaction format, the goods or services being traded, and the parties involved.

[0159] An application service provider (ASP) can create a software package (EDI service app) related to these EDI services and register it in a database or store it in an application repository (Registry).

[0160] A software package refers to a bundle of software that includes components that enable clients to install and use the software. In this example, the software package (App package) is represented as a package that includes an application and its executable binary or library parts.

[0161] Therefore, the software package may take the form of a file, which is a software image that runs on virtualized cloud resources.

[0162] Each client can download, change, or execute software packages (EDI service apps) stored in the registry or registered in the database in each workspace (not shown).

[0163] Software packages (EDI service apps) stored in a repository or registered in a database can be downloaded or executed on nodes providing each workspace, even if they are the same package.

[0164] Each client can download the necessary software package (EDI service app) as a software image in its own isolated workspace (not shown) and use it for the desired EDI service.

[0165] Each client can download the software image and use it to obtain the desired EDI service, or can provide EDI services to the client's partners.

[0166] If a client provides the desired EDI service by downloading the software image in an isolated workspace, the software package (EDI service app) can be stored in a registry or registered in a database.

[0167] An Application Service Provider (ASP) provides an instance system that allows clients to use, modify, or provide software packages related to services such as EDI services, and can manage data transmission and reception with the instance system. This is described in detail below.

[0168]

[0169] Figure 4 is a conceptual diagram disclosing layer-by-layer elements for providing application services according to an embodiment.

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

[0171] The manager system (2000) can provide application services, such as EDI services, using an on-premise system or a cloud system. Detailed examples of services provided by the manager system (2000) are described below.

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

[0173] A computing system may also include a virtualization layer, such as a container or virtual machine (VM), that can virtualize computing resources.

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

[0175] For example, computing systems can provide containers as a virtualization layer. Containers can use the host's resources as needed to run applications on top of the host operating system (OS). Container images can be used to rapidly develop and deploy applications.

[0176] 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).

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

[0178] The client (100) can receive application services, i.e., software packages, provided by the manager system (2000) through a system having layers as exemplified in this drawing.

[0179] 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). The applications or services on the workspace (1500) are described in detail below.

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

[0181] 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).

[0182] The manager system (2000) can provide an environment in which clients can develop applications necessary for their transactions.

[0183] 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) can manage the computing environment that provides the development workspace (3000) to a client (100) or partner (200), and enable the client (100) or partner (200) to develop necessary applications in the development workspace (3000).

[0184] This development workspace (3000) may include a development tool application that can develop applications, a billing application (payment / billing) that determines the usage and billing system for the developed applications, an app store (app. Store) that can sell the developed applications, and a back-office application that supports and controls these functions.

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

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

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

[0188] The manager system (2000) may also provide inspection and control of the client system through the interface governance platform (4000) on the solution API (4100). These services are disclosed in detail separately.

[0189] Below, detailed examples are described in which a client (100) receives or provides a service using a software package through a workspace (1500).

[0190]

[0191] FIG. 5 is a diagram illustrating a concept of an application service providing device according to an embodiment establishing a channel between an instance and a client or partner.

[0192] As disclosed, the instance system may include at least one node. For example, the instance system may include a coordinator node and worker nodes that transmit and receive software packages to and from the coordinator node.

[0193] An instance system can expand not only its worker nodes but also multiple instance systems. Therefore, it can provide a continuously expanded system environment and services even as the number of clients increases.

[0194] In order to provide application services, the application service manager (2100) can collect information such as resources from clients or partners (300).

[0195] In this case, if the application service manager (2100) directly accesses the system of the client / partner (300) to collect resource information of the client / partner (300), a security issue may arise.

[0196] Accordingly, the embodiment can install an agent (350) on a client / partner (300) and enable the client / partner (300) to directly manage connection information.

[0197] The agent (350) can set connection information for resource management information or connection information within the client / partner (300). In this example, the agent (350) can collect resource management information or connection information of the client / partner (300), user information of the client / partner (300), and other file system information. In addition, the agent (350) can access the database of the client / partner (300) and collect stored information. The agent (350) can store the collected information.

[0198] The agent (350) of the client / partner (300) can be connected to an agent adapter (1350) installed on the Nth node (Node #n) (1300), which is an arbitrary node of the instance system that can receive application services.

[0199] The application service manager (2100) can obtain information related to the client / partner (300) collected from the agent (350) of the client / partner (300) from the agent adapter (1350) installed in the N node (1300).

[0200] The Nth node (1300) may include a configuration storage (Config. Repository) (1330), which may store information set by the manager system (2100), for example, configuration information for the agent or information transmitted and received between the agent and the agent adapter. The agent adapter (1350) may store various pieces of information received from the agent (350) of the client / partner (300).

[0201] The application service manager (2100) may include a message box (2110), which may receive information stored in the agent adapter (1350) of the Nth node (1300) (outbox slot) or request information from the agent adapter (1350) (inbox slot).

[0202] The agent adapter (1350) transmits information (inbox slot) received from the message box (2110) of the application service manager (2100) to the agent (350) of the client / partner (300). In addition, the agent adapter (1350) transmits information (outbox slot) received from the agent (350) of the client / partner (300) to the message box (2110) of the application service manager (2100).

[0203] The message box (2110) is a storage device that can store data, files, or documents to be transmitted and received, and may be configured as a separate server. Accordingly, the message box (2110) may also be referred to as a message server, but in the example of this drawing, it is represented as a message box as a unit of logical distinction and monitoring.

[0204] An agent (350) registered with a client / partner (300) can send data to an agent adapter (1350). In addition, the agent (350) can receive or poll data from the agent adapter (1350) at regular intervals.

[0205] The configuration storage (Config. Repository) (1330) of the Nth node (1300) that provides a service to a client / partner (300) can store channel configuration information between the agent (350) and the agent adapter (1350) or configuration information that the agent adapter (1350) receives from the agent (350).

[0206] The application service manager (2100) can provide or obtain information necessary for the service provided to the client / partner (300) from the agent adapter (1350) installed on the node (1300).

[0207] Since the agent (350) collects only the necessary information of the client / partner (300), security issues occurring in the client / partner (300) can be minimized. In addition, since the agent (350) does not retrieve unnecessary data and data is transmitted and received at regular intervals, channel overload between the Nth node (1300) and the client / partner (300) can be prevented.

[0208] The N node (1300) stores the necessary information in the configuration storage (Config. Repository) (1330), so that the information collected by the agent (350) can be maintained up to date and the channel can be made lightweight.

[0209] According to an embodiment, the latest status of information related to the client / partner (300) can be stored in the Nth node (1300), thereby enhancing security without burdening the client / partner (300).

[0210] The following describes in detail how to transmit and receive information required for the service of the agent adapter (1350) within the N node (1300) through a channel set as in the disclosed example.

[0211]

[0212] FIG. 6 is a drawing 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.

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

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

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

[0216] A channel is configured to use a service provided by the application service manager (2100). It can be described as a component for connecting to a package, such as an adapter package. Examples related to this are described in detail below.

[0217] The client / partner (300) may have an agent (350) installed, 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).

[0218] An agent (350) can request a software package from a coordinator (1100) of an instance system (1000). In this case, the agent (350) can request a channel service for receiving the software package from an agent adapter (1350) of the coordinator (1100). Here, an HTTP request can be used for the channel service requested by the agent (350) to the agent adapter (1350).

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

[0220] Information for installing the agent (350) already includes path information that can access the instance system (1000).

[0221] 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 a synchronization time with the agent adapter (1350) of the Nth node (1300).

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

[0223] 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).

[0224] 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 the inbox slot in the message box (2110), respectively, according to the information set as above. The slot in the message box is a logical division concept that stores a data processing unit, and the message box can store and output a data processing unit like a queue.

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

[0226] In this way, when the agent (350) is registered to the client / partner (300) and the agent adapter (1350) is set to the instance system (1000), the agent adapter (1350) can be connected to the resource set to the agent (350).

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

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

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

[0230]

[0231] FIG. 7 is a diagram disclosing an example of managing channels and providing services in a distributed system according to an embodiment.

[0232] As illustrated, nodes within the instance system (1000) can transmit and receive data via channels to provide services. A channel is a general term for a path that calls data or packages for providing services, or searches for a node on which a previously registered channel is running.

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

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

[0235] For example, the coordinator (1100) can register and store information about packages stored in 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 can register and store information about adapter package B stored by the worker node (1120) of the second node (Node #2).

[0236] The coordinator (1100) can receive service requests related to packages from clients or partners. As described above, this example illustrates a case where the service request is received via an HTTP request containing URL information.

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

[0238] As in the example here, the coordinator (1100) establishes an HTTP service channel based on an HTTP request containing URL information from 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.

[0239] Since clients or partners use isolated workspaces provided by the coordinator (1100), the versions of packages within each workspace of clients (or partners) may be different and different versions of adapter packages may be used.

[0240]

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

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

[0243] If a client or partner develops an application package in that workspace, they may need an integration package that includes Adapter Package B.

[0244] The coordinator (1100) knows that the first worker node (worker node #1) (1110) stores the integrated package and the second worker node (worker node #2) (1110) stores the adapter package B based on the registered information.

[0245] The coordinator (1100) can search for an integrated package including adapter package B in the first worker node (worker node #1) (1110) through an adapter function channel. 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.

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

[0247] In this disclosed embodiment, multiple packages can be distributed and installed across multiple nodes. To enable communication between packages or to call a specific adapter package from outside the instance system, the coordinator (1100) can manage and store channels that search for, call, or register the corresponding package on worker nodes capable of providing package services.

[0248] The agent adapter (1350) of the coordinate (1100) instance system (1000) can set up transmission and reception channels from the agent (350) as exemplified. The agent adapter (1350) can set up a specific agent and channel using information related to the channel, such as the agent's identifier and channel period.

[0249] In this way, the coordinator (1100) can manage various pieces of information so that requested package-related services can be distributed and performed across worker nodes. While the HTTP service channel is exemplified above, packages can also be delivered via a file transfer channel such as FTP.

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

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

[0252]

[0253] FIG. 8 is a drawing disclosing an example of managing setting information of a package installed according to an embodiment.

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

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

[0256] The application service manager (2100) can store the configuration information of a package in a database (2200). The application service manager (2100) can obtain the configuration information of a package from a specific node, in this example, node #m (3110), or store the configuration information of a package requested externally in the database (2200).

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

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

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

[0260] 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 (3215).

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

[0262] When the package setting information of node #m (3110), which is a worker node, is changed, the changed setting information of the package can be transmitted to the application service manager (2100).

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

[0264]

[0265] FIG. 9 is a diagram showing an example of managing and using packages according to a workspace of an embodiment of the disclosure.

[0266] Clients can create, run, and modify multiple packages in an isolated workspace.

[0267] For example, a client can execute an adapter package in a workspace, which can use configuration information stored in a configuration repository. However, in some cases, the package may also reference resource files in addition to the configuration information stored in the configuration repository.

[0268] Resource files can be installed in the workspace as mapping programs, a type of resource package. Resource files can be accessed using resource paths when executing packages, such as adapter packages, to enable the adapter package to run.

[0269] According to the disclosed embodiment, both development or testing and operation of packages are possible in the workspace.

[0270] Therefore, according to an embodiment, resource files can be provided by separating a workspace for operation and a workspace for development.

[0271] In the example of this drawing, when developing an adapter package in the development workspace (1510), 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 specifying it as a writable shared resource path.

[0272] On the other hand, when running an adapter package in an operational workspace (1520), the resource file may be provided as a resource package that the adapter package can only read but not write. In this case, the adapter package can reference the resource package to install and access it, but cannot modify the resource files within the resource package.

[0273]

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

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

[0276] Below, an example of such application service is described, using an EDI service as an example. As those skilled in the art will readily appreciate from the disclosure, the embodiments described herein can be used to develop or provide a variety of application services, and thus are not necessarily limited to EDI services.

[0277] As a type of application service, EDI requires various types of transactions, parties, and transaction formats across industries. Therefore, utilizing examples that address the complex and diverse transaction patterns of each industry enables efficient transactions, making it highly effective in stimulating industrial transactions.

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

[0279] EDI has a wide variety of formats, each with specific rules and regulations for each industry. EDI documents must be created and processed according to these formats to complete a transaction. EDI services vary across various industries, including e-commerce, transportation, logistics, finance, and insurance. EDI is standardized by international standards organizations such as ISO and is regulated and managed by UN / EDIFACT (United Nations / Electronic Data Interchange for Administration, Commerce, and Transport) and ANSI (American National Standards Institute) X.12.

[0280] Depending on the nature of the transaction, which involves ordering and supplying, different forms of documents containing different data or information may be used, and the systems used by the parties to the transaction may also be different.

[0281] For EDI service, documents between two trading parties must be mapped.

[0282] This drawing example conceptually discloses an advanced mapping engine, a program that transforms documents containing data into a general-purpose system to provide EDI services.

[0283] For example, a trading partner may provide an EDI document and EDI schema required for the transaction. This data can be decoded into unmarshal data by decoding the bytes or strings contained in the EDI data (i.e., the EDI document) according to the input schema.

[0284] A mapping engine may include reference information for mapping schemas based on the data to be converted and the schemas of the data being converted. This mapping reference information is referred to herein as a mapping script.

[0285] The mapping criteria information can be in script format to convert the unmarshalled data into a document of a different format targeted at other purposes.

[0286] A mapping engine can convert EDI data and EDI schema decoded data (unmarshal data) into a file of a specific format that can be used as an interface to a general document (here, a JSON file as an example) and into a schema for the file of the specific format (here, a JSON schema as an example).

[0287] In more detail, the EDI format of the SEF (Standard Exchange Format) standard can be used as an EDI schema, or an EDI format such as EXF (EDI Exchange Format) can be used.

[0288] The changed format file can be a flat file, JSON, XML, etc.

[0289] When marshalling or unmarshalling each file type for a file in a changed format, it can be converted into a schema file defined by annotations. In other words, the marshalling or unmarshalling result can be obtained as a schema that defines the type corresponding to the data to be converted and the annotation corresponding to the specific data type.

[0290] The embodiment may provide a user with a graphical interface that enables the user to create a schema through such a mapping engine and write a mapping script, which is mapping reference information.

[0291]

[0292] FIG. 11 is a drawing disclosing an example of providing an application service using an integrated package according to an embodiment.

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

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

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

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

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

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

[0299] 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).

[0300] 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).

[0301] Here, the integration package (1380) is a bundle of integrated development items, including various development flows and Java or script programs. The integration package (1380) allows for the combined use of these development items and can address integrated requirements.

[0302] The integration package (1380) can implement various requirements that can be traded between the client (310) and the partner (320) by exchanging information with the message box (2110), adapters of the worker nodes (1350, 1370, 1390) and the channel service of the coordinator.

[0303] The integration package (1380) can address user requirements by creating and registering routing for exchanging necessary information within the package when a specific channel is called according to a distributed channel service.

[0304] The elements and usage examples for the integration package (1380) are described in detail below.

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

[0306] 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 information required by the partner (320).

[0307] 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 forward it to the EDI adapter (1390).

[0308] 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.

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

[0310] 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 the channel service, and convert it into HTTP traffic and transmit it to the partner (320).

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

[0312] Accordingly, clients (310) and partners (320) can easily use application services such as EDI services according to the disclosed embodiments, and can easily conduct 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 transaction counterparty.

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

[0314] The embodiment can be provided through a very easy interface for developing such packages and connecting them with existing packages, and the developed packages can also be sold, shared, or provided separately.

[0315]

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

[0317] This diagram illustrates the interface provided by the platform when a user accesses the platform, for example, to provide application services.

[0318] When a client connects to a system that initiates a platform, the platform may present a user interface menu associated with the user's dedicated workspace.

[0319] A client can access the instance system through an interface platform provided by the manager system as illustrated in this drawing, or by using HTTP including a URL.

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

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

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

[0323] Users can check the packages they use or develop (161) or the packages they have purchased (162) by selecting the user interface menu.

[0324]

[0325] FIG. 13 is a diagram illustrating another example of an interface of a platform according to an example of providing an application service disclosed.

[0326] This diagram illustrates the user interface menus that can be viewed when a client accesses a platform providing application services initiated by the client and selects their workspace.

[0327] The client can check and use the workspace (171) it created, the instance system (172) related to the workspace, the creation date for each workspace (173), the description information of the workspace (174), whether the workspace is activated (175), and the services (176) and packages (177) related to the workspace.

[0328]

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

[0330] The instance system according to the embodiment can provide a framework for integrating these different systems, and the embodiment is disclosed as follows.

[0331]

[0332] FIG. 14 is a drawing disclosing an example of an application service providing device according to an embodiment providing a framework that can integrate different systems.

[0333] 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 enable users of different systems to connect with each other, making it efficient and ideal for providing EDI services, such as the ones exemplified above.

[0334] This diagram 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.

[0335] A route engine provides routes by connecting endpoints, which are different systems, and processors, which are tasks performed between endpoints.

[0336] Routes can describe the interface between systems, and in this example, the route engine provides routes 1, 2, …, N.

[0337] A processor refers to 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 exemplified.

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

[0339] A component that gets or receives data from (or is called by) a component is called a consumer, and a component that calls, transmits, or retrieves data from a component is called a producer.

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

[0341] An exchange is a container that holds messages exchanged between systems. It is an object that is created when the route flow begins and its life cycle lasts only until the flow ends.

[0342] This integrated system architecture allows for the creation of applications that can be used across different systems and developed as an integration package. An example of this is the integration package (1380) illustrated in the example above.

[0343] 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 a platform according to an embodiment.

[0344] 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.

[0345] Clients (or partners) can create integrated packages necessary for their service provision using the integrated system architecture exemplified above based on the platform according to the embodiment.

[0346] The platform according to the embodiment can also provide an environment in which a client (or partner) can very easily develop an integrated package that implements an integrated flow using graphical coding.

[0347]

[0348] Below, an environment in which an integration flow can be developed as an integration package provided by the integrated system architecture of the platform according to an embodiment is exemplified.

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

[0350] Clients (or partners) can use the examples to develop graphical integration flows, which can broadly include five functions.

[0351] Here, the five functions included in the integration flow are referred to as connectors, services, processors, control flows, and modifiers. These names are merely examples, and each function is described in detail below.

[0352]

[0353] Figure 15 shows an example of graphically coding a connector among the integration flow functions when developing an integration flow based on an embodiment.

[0354] A connector may contain a From graphical element that represents the start of a route in the integrated system architecture illustrated above.

[0355] A connector can include a To graphic element that defines external actions, such as calling a service or adapter, storing data, etc., when a flow developed in a development environment is implemented.

[0356] As illustrated in this drawing, an integration flow can be developed using a connector that can express the input / output (From / To) of a route in graphical coding in a graphical development environment provided by the embodiment.

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

[0358] A consumer can be a direct caller 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.

[0359] There may also be other cases where the integration flow calls (From Connector) specific data, such as a channel that registers a route as a channel and starts a route when the channel is called, a message box that periodically checks for unprocessed messages and starts a route if there are any, or an FTP that checks if there are documents in the registered FTP service path and starts a route if there are documents.

[0360] These consumers can include options such as a Route ID within the unified package, Auto Start, which indicates whether the route should be started at package installation time, and Start Order, which indicates the start order of the corresponding routes upon package installation.

[0361] A producer represents the external output action (To connector) of a connector as a result of the execution of an integrated flow. Producer types include "direct," which refers to calling another direct route within the same application package, and "message box," which refers to saving a document in a message box. Additionally, there may be "channel," which refers to calling another channel within the workspace as a producer, or "FTP," which refers to transferring a document to a registered FTP service.

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

[0363]

[0364] Figure 16 shows an example of graphically coding a service among the integration flow functions when developing an integration flow based on an embodiment.

[0365] An integration flow that can be developed graphically according to an embodiment can be coded based on a visual interface using service blocks.

[0366] In the example of this drawing, the service block may include a getNextControlNumber element, an isDuplicatedControlNumber element, a putUsingControlNumber element, a remoteCache element, etc., which are provided graphically.

[0367] The getNextControlNumber element means issuing a new control number, and the isDuplicatedControlNumber element is an element that checks whether the control number is duplicated.

[0368] In this drawing, you can define whether the control numbers are duplicated (True) or not (False).

[0369] Among the service blocks in developing an integrated flow, the putUsingControlNumber element stores the used control number in storage and uses it to check for duplication, and the remoteCache element exemplifies accessing the workspace's cache service.

[0370] Therefore, integration flows can be graphically coded using service blocks such as the example in this drawing.

[0371]

[0372] Figure 17 shows an example of graphically coding a processor among the integration flow functions when developing an integration flow based on an embodiment.

[0373] An integration flow that can be developed graphically according to an embodiment can be coded based on a visual interface using processor blocks.

[0374] In the example of this drawing, the processor block may include a log element, a process element, an xslt element, a groovy element, and a delay element, which are provided graphically.

[0375] The log element records the necessary information when executing a flow in the package log, and the package log can be checked by the adapter that monitors the execution status of the package.

[0376] The process element allows you to perform custom processing by calling the method of a Bean registered in an uploaded Java (Jar) package item.

[0377] The xslt element allows you to select an XSLT package item to perform an XSLT transformation.

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

[0379] The delay element can be used to delay the flow's route for a short period of time.

[0380] Therefore, integration flows can be graphically coded using processor blocks such as the example in this drawing.

[0381]

[0382] Figure 18 shows an example of graphically coding the control flow among the integration flow functions when developing an integration flow based on an embodiment.

[0383] An integration flow that can be developed graphically according to an embodiment can be coded based on a visual interface using a control flow block.

[0384] In the example of this drawing, the Control flow block may include a split element, a for element, a while element, an xslt element, an If or Switch-Case element, and a Try-Catch element, which are provided graphically.

[0385] The split element records the necessary information during flow execution in the package log, which can be checked by the adapter that monitors the package execution status. The split element is a function that can split a single integrated document (Exchange) into multiple Exchanges for processing, and can support Delimiter, XPath, and Bean methods.

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

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

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

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

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

[0391]

[0392] Figure 19 shows an example of graphically coding a modifier among the integration flow functions when developing an integration flow based on an embodiment.

[0393] An integration flow that can be developed graphically according to an embodiment can be coded based on a visual interface using a modifier block.

[0394] In the example of this drawing, the modifier block may include a loadProperty element, a setProperty element, a setHeader element, a setBody element, a removerHeader element, and a removeProperty element, which are provided graphically.

[0395] The loadProperty element provides the ability to retrieve a settings node from a settings store and store it in an Exchange Property.

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

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

[0398] The setBody element can provide the ability to specify values ​​for the Exchange Message Body.

[0399] The removerHeader element can provide the ability to remove a value from an Exchange Message Header.

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

[0401] You can graphically code an integration flow using the example modifier block.

[0402]

[0403] Below, an example is disclosed that can distinguish users such as clients and isolate each workspace according to the embodiment disclosed above.

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

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

[0406] A detailed example is as follows:

[0407]

[0408] FIG. 20 is a diagram disclosing an example of providing a unique workspace isolated for each client according to an embodiment.

[0409] In the illustrated example, the instance system (1000) may include a coordinator (not shown) and one or more worker nodes, and in this example, multiple worker nodes (Node #1, Node #2, Node #3, Node #N) are illustrated.

[0410] A coordinator (not shown) according to an embodiment can allow access through user authentication when a user accesses the system and provide each user with a workspace.

[0411] In this example, it is assumed that client 1 (110), client 2 (120), and client 3 (130) access the instance system (1000) according to the embodiment.

[0412] The manager system (not shown) can manage the coordinator and worker nodes (Node #1, Node #2, Node #3, Node #N) of the instance system (1000).

[0413] The instance system (1000) can provide workspaces (1510, 1520, 1530) that are isolated from each other depending on the user when each client (110, 120, 130) connects through a coordinator (not shown).

[0414] In this example, client 1 (110) can be assigned and use workspace A (1510), client 2 (120) can be assigned and use workspace B (1520), and client 3 can be assigned and use workspace C (1530).

[0415] When client 1 (110) is assigned workspace A (1510) on the instance system (1000), worker node 1 (Node #1) can provide package E, which is a workspace bundle unique to workspace A (1510).

[0416] Here, a workspace bundle represents a group of extensible software programs that contain detailed metadata as a software package.

[0417] At this time, worker node 1 (Node #1) can provide software package E as a workspace bundle that is dependent on workspace A (1510) or unique to workspace A (1510) at the request of client 1 (110).

[0418] Here, the dependency of a software package on workspace A (1510) means that the software package E provided by the framework of the worker node (Node #1) contains authentication information related to workspace A (1510).

[0419] That is, the framework of worker node 1 (Node #1) provides package E, a software bundle including authentication information related to workspace A (1510) as a unique workspace bundle, to workspace A (1510).

[0420] Similarly, the framework of worker node 2 (Node #2) provides package E, a software bundle including authentication information related to workspace B (1520), as a bundle of unique workspace B (1520) at the request of client 2 (120), to workspace B (1520).

[0421] Similarly, the framework of worker node 3 (Node #3) provides package E, a unique software bundle containing authentication information related to workspace C (1530), to workspace C (1530) at the request of client 3 (130).

[0422] Here, each worker node (Node #1, Node #2, and Node #3) provides the same software package E, but provides software package E with unique authentication information to each workspace (1510, 1520, 1530).

[0423] Accordingly, since an image combining the same software package E and different unique authentication information is provided for each workspace (1510, 1520, 1530), the clients (110, 120, 130) may have the effect of being isolated in their respective workspaces.

[0424] Thus, in this example, the framework of worker node 1 (Node #1) provides package E containing identification information of workspace A and a separate package F to workspace A (1510), the framework of worker node 2 (Node #2) provides package E containing identification information of workspace B and a separate package G to workspace B (1520). Similarly, the framework of worker node 3 (Node #3) provides package E containing identification information of workspace C and a separate package H to workspace C (1530).

[0425] The identification information of each workspace can be used as information to authenticate each workspace. An example of authentication information is a non-repudiation token based on the RSA (Rivest-Shamir-Adleman) encryption algorithm.

[0426] Therefore, when each client receives application services through each workspace, the instance system can authenticate each client's authorization to the application services by verifying the application services provided for each workspace based on the authentication information of each workspace.

[0427] Therefore, when application services are provided according to software bundles through each workspace, a unique software bundle is installed in each workspace, and the services and execution areas provided accordingly can be isolated.

[0428] When a software package is requested from a workspace, worker nodes (Node #1 to Node #N) can approve or deny the download or execution of the requested application based on the authentication information unique to each workspace.

[0429] Meanwhile, a Java framework such as OSGi can be used as an example of a framework for worker nodes (Nodes #1 to #N). OSGi is a Java framework that can provide software bundles containing Java components and metadata in a runtime environment. In this case, worker nodes (Nodes #1 to #N) can provide the OSGi framework.

[0430]

[0431] FIG. 21 is a flowchart illustrating an example of providing a package to a client from an isolated workspace according to an embodiment.

[0432] A request for an application package is received from a client (or partner) using the workspace (S110).

[0433] The manager system can manage instance systems to provide services for application packages.

[0434] An instance system can provide a workspace to each client (or partner) based on a coordinator and worker nodes.

[0435] Each client (or partner)'s workspace can be isolated, and the client (or partner) can request service for application packages from the instance system through the isolated workspace.

[0436] Authentication of the requested application package is performed based on the authentication information included in the software bundle related to the above workspace (S120).

[0437] When a worker node providing a workspace within an instance system installs a software bundle into that workspace, it can install a software bundle that contains credentials unique to that workspace.

[0438] Here, the authentication information can provide authorization to use other application package services. For example, a non-repudiation token based on the Rivest-Shamir-Adleman (RSA) encryption algorithm can be used as authentication information.

[0439] Therefore, even if the same software bundle is installed across workspaces provided by a worker node, each workspace may contain different credentials. This allows a software bundle to establish a dependency on the workspace in which it is installed.

[0440] And, you can use the authentication information of the workspace as an authentication key to authenticate the application package of the requested service.

[0441] Workspaces can be isolated from each other by providing workspaces that can run the same software bundles, excluding their authentication information. This means that even if the same software is running in a workspace, the workspaces can be isolated from each other because they contain different authentication information.

[0442] Depending on the result of the above authentication, the service request for the received application package is approved or rejected (S130).

[0443] When a worker node provides an application package requested from a workspace, the credentials of the software bundle installed in that workspace can be used as credentials for that workspace. Examples of frameworks capable of providing such workspaces include the OSGi framework.

[0444] Therefore, the worker node can provide the requested application package to the workspace only if the workspace is authenticated, based on the authentication information of the software bundle installed in each workspace.

[0445] If the credential information of the software bundle installed in the workspace does not match, the worker node refuses to provide the application package service requested for that workspace.

[0446] The application service providing device according to the embodiment disclosed above may include a manager system and an instance system.

[0447] An instance system is at least one server including a coordinator and worker nodes, wherein the server may include a storage medium for storing data and a processor.

[0448] At this time, the server's processor may receive a service request for an application package from a client and authenticate the requested application package based on authentication information contained in a software bundle associated with the workspace. Furthermore, the instance system's processor may perform operations to approve or reject the service request for the received application package based on the authentication results.

[0449] If the above example is implemented as an instance system-based program, the program can receive a service request for an application package from a client using the workspace. The computer-executable program can authenticate the requested application package based on authentication information contained in a software bundle associated with the workspace, and approve or reject the service request for the received application package based on the authentication result.

[0450] Even if the software packages provided to clients (partners) using the workspace are the same, if different software images are run for each client (partner), all versions and types of software packages must be prepared and provided for each client (partner).

[0451] However, by using a framework that provides workspaces in which software bundles containing unique authentication information for each client are executed, as in the disclosed embodiment, workspaces can be isolated from each other and application services can be provided using the same software package, allowing for efficient operation of computing resources.

[0452]

[0453] The above example discloses a channel through which clients or partners can send and receive relevant information based on a platform provided by the manager system.

[0454] Below, we present an embodiment that allows a client and partner, as described above, to exchange data while maintaining information security. The above example illustrates an example in which an agent within a client or partner and an agent adapter within a platform provided by an instance system exchange information.

[0455] Accessing a client or partner without installing an agent in this way can cause security issues on the client or partner's system. To avoid this issue, the client or partner can install an agent. Furthermore, the manager system can easily perform patches or upgrades using the agent installed in the client or partner.

[0456] Additionally, the agent adapter can perform protocol conversion or data conversion for data transmission and reception, thereby converting the channel transmitted from the agent or the protocol for data transmission and reception to facilitate communication.

[0457] Agents can manage connection information for installed clients or partner systems. In this case, agents can configure connection information for resource access on the client or partner system. For example, agents can configure databases, file systems, user information, resource access, or management information for the installed system. They can also poll information from the agent adapter according to set cycles or conditions.

[0458] 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 installed on client or partner systems according to set cycles or conditions.

[0459] The coordinator of an instance system can establish a channel through which agents can connect. When a request is received from an agent on the established channel, the coordinator can map the channel and forward it to the agent adapter on the worker node.

[0460] When installed on a client or partner system, an agent may have various configuration information. For example, an agent application may have configuration information that includes agent-related configuration information, security key information related to agent execution, resource management configuration information, and user management information.

[0461] The platform of an instance system can provide a connection interface through which clients or partners can download and run agent applications.

[0462] Below we illustrate the user interface of an agent or agent adapter and describe an example of controlling it.

[0463]

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

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

[0466] This diagram illustrates the agent's interface when the agent application is running and the agent is run by an administrator or user.

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

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

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

[0470] Client or partner administrators can use a menu (2120) to manage their own resources that can be managed via agents. In the example of this diagram, the resource management (2120) menu represents resources that can be included and managed in the client or partner system, such as databases, directories, SAP systems, or IBM MQ systems. Administrators can manage resources through the resource management (2120) menu and set location information, connection information, and connection paths for each resource.

[0471] Additionally, the client or partner administrator can manage agent users through the agent using the user management menu (2130). The administrator can manage agent users and set permissions for each user using the user management menu (2130).

[0472]

[0473] FIG. 23 is a drawing illustrating an example of an interface of an agent adapter provided on a platform of an instance system according to an embodiment.

[0474] Clients or partners can utilize the agent adapter provided by the instance system's platform. Clients or partners can register agents exemplified in the agent adapter provided by the instance system's platform.

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

[0476] 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.

[0477] And the agent adapter interface 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.

[0478] The agent adapter interface includes a means (2295) for activating connection or synchronization with a registered agent as described above. This example discloses an example in which the agent adapter transmits and receives information with an agent through a button (2295) that is activated to synchronize with the agent.

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

[0480] In this way, agent adapters can be used to register or modify agent configuration information installed on clients or partners. Agents configured through agent adapters can connect to resources on the system where they are installed and send and receive data with the instance system.

[0481] As explained, a transmission channel refers to a channel that periodically retrieves information from resources of a partner (or client) system 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 set location and format on the partner (or client) system.

[0482] Therefore, setting up a transmission channel here means setting up information or documents to be retrieved from an agent installed on the client or partner's system and stored in a message box.

[0483] And the setting of the receiving channel means the setting of storing information or documents received by the agent adapter through the channel setting in a certain location of the client or partner's system.

[0484] Below, examples of channel configuration are detailed. Agent adapters can control the transmission and reception of information or documents through channel configuration.

[0485]

[0486] FIG. 24 is a diagram illustrating another example of an interface of an agent adapter provided on a platform of an instance system according to an embodiment.

[0487] The channel types configured for agent adapters installed on nodes of an instance system can vary, and different settings can be configured for transmit and receive channels in the agent adapter. The channel type configured for each adapter can be the same as the type of resource managed by the agent.

[0488] This diagram illustrates the resources managed by an agent. In the example shown, the agent manages a database, a directory, an SAP system (SAP JCO) within the system on which it is installed, and an IBM system (IBM MQ) within that system.

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

[0490] Here, the agent adapter can set the Java Connector (JCO) (2330) as the channel type for the SAP system, and the Message Queue (MQ) (2340), which is a network software, as the channel type for the IBM system.

[0491] Here, we have used SAP and IBM systems as examples, and even if the client or partner system includes other systems, you can set the channel type related to that system.

[0492]

[0493] FIG. 25 is a diagram showing an example of an agent adapter of a platform of an instance system according to an embodiment setting up a transmission and reception channel.

[0494] This example illustrates setting up a transmit channel (top) and setting up a receive channel (bottom) that the agent adapter transmits.

[0495] In this example, when setting up a transmission channel (top), it is assumed that the agent ID of the agent that the agent adapter transmits to is test-agent, the channel ID is file-send, the adapter type is file (FILE), the transmission direction (Direction) is send (SEND), and the adapter version (adapter version) is 1.0.

[0496] Agent adapters can set the polling schedule in seconds or cron, and can set the channel depending on the adapter type.

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

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

[0499] In this example, when setting up a receiving channel (bottom), the agent ID of the agent receiving from the agent adapter is assumed to be test-agent, the channel ID is assumed to be file-recv, the adapter type is assumed to be file (FILE), the transfer direction is assumed to be transfer (RECV), and the adapter version is assumed to be 1.0.

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

[0501]

[0502] Figure 26 discloses an example of transmitting EDI data, which is transaction information, using a platform of an instance system according to an embodiment.

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

[0504] 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).

[0505] Meanwhile, an agent (350) installed in a 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).

[0506] In general, 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) can each be logical components of the software. Similarly, 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) can each be logical components of the software.

[0507] To transmit and receive data from client or partner systems as transaction data, such as EDI data, clients or partners can install agents to communicate information with internal systems. This example illustrates a situation where the client or partner system includes internal systems such as an SAP ERP system, a database such as an RDBMS, or an IBM system's message queue.

[0508] The agent control unit (1351) can control an agent (350) installed in a client or partner system. For example, the agent control unit (1351) can start, terminate, or update an agent (350). In this case, if the agent control unit (1351) does not directly request and control the agent (350) but only updates the request information to control 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 according to the request information.

[0509] The transmission / reception setting unit (1352) of the agent adapter (1350) can change and set 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) without being transmitted to the agent (350).

[0510] Then, the transmission / reception setting processing unit (353) of the agent (350) can periodically retrieve the transmission / reception processing information changed by the transmission / reception setting unit (1352) of the agent adapter (1350) and save the transmission / reception processing information as a file. The stored 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. Therefore, the agent adapter (1350) can remotely set and control the transmission / reception operation of the agent (350).

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

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

[0513] In this way, a platform according to an instance system can install an agent on a client or partner system and enable the installed agent and the agent adapter of the platform to communicate, thereby stably communicating the system data of the client or partner.

[0514] Additionally, agents communicate with agent adapters through authentication, and agent adapters can remotely configure settings for agent data transmission and reception. This minimizes the need for agent adapters to directly configure actions or information on agents, making configuration management safe and easy.

[0515]

[0516] FIG. 27 discloses an example in which a platform of an instance system according to an embodiment provides data to a client system.

[0517] The platform of the instance system according to the embodiment can provide data transmitted from a partner system to a client system.

[0518] The embodiment sets channel information to be provided to a first computing system external to the platform based on a platform providing an isolated workspace (S171).

[0519] A platform providing an isolated workspace includes an instance system, which may include one or more nodes. As an example, the first computing system may be a partner (or client) system, in which case the agent adapter installed on the worker node of the instance system may be configured with channel information to be provided to the agent installed on the partner system.

[0520] When an agent adapter is installed on a worker node of an instance system that provides a workspace, the agent adapter can set its channel information to the coordinator of the instance system through the worker node.

[0521] The above channel information includes a channel type, and the channel type may include a channel type that can access a database, a file type that can be sent and received in a directory, a connector type of a computing system, a message type of computer network software, etc. An example related to channel settings is disclosed in FIG. 25.

[0522] Data related to the first computing system is received according to the above-set channel information (S175).

[0523] When channel information is set to the agent adapter as above, data related to the first computing system can be received from an agent installed on a partner (or client) system, which is the first computing system.

[0524] That is, under certain conditions, information related to the partner system can be received from an agent of the partner system according to the channel information set above.

[0525] The data related to the first computing system received above is provided to a second computing system using the workspace outside of the platform (S179).

[0526] The received information can be provided to a client system, which is a second computing system, and thus data such as transaction information between the partner system and the client system can be transmitted and received through the platform of the instance system according to the embodiment.

[0527] A detailed example of a worker node with an agent adapter installed among instance systems receiving data transmitted from a partner system is disclosed in Fig. 26.

[0528]

[0529] FIG. 28 discloses an example in which a platform of an instance system according to an embodiment receives data from a partner system.

[0530] Channel information established based on a platform providing an isolated workspace is provided to an agent installed on a first computing system outside of the platform (S181). An example of channel setup is disclosed in FIG. 25.

[0531] When an agent adapter is installed on a worker node within an instance system that provides a workspace, the agent adapter can provide configured channel information to an agent of an external first computing system (partner or client system) under certain conditions.

[0532] The above channel information includes a channel type, and the channel type may include a channel type that can access a database, a file type that can be sent and received in a directory, a connector type of a computing system, a message type of computer network software, etc. An example related to channel settings is disclosed in FIG. 25.

[0533] Based on the channel information provided above, data collected in relation to the first computing system can be received (S185).

[0534] An agent adapter installed in an instance system can receive data related to the partner (or client) system, which is the first computing system, based on the provided channel information.

[0535] The collected data can be stored in a storage medium and the stored data can be provided to a second computing system external to the platform (S189).

[0536] Data from the partner system, the first computing system, may be related to or required for transactions such as EDI. The client system, the second computing system, may store the information received from the partner system, the first computing system, in a storage medium such as a message box. Based on the platform providing the workspace, the stored data may be provided to the client system.

[0537] An example of providing for storing data from a received partner system in a message box is disclosed in Fig. 26.

[0538] The application service providing device according to the embodiment disclosed above may include a manager system and an instance system.

[0539] An instance system is at least one server including a coordinator and worker nodes, wherein the server may include a storage medium for storing data and a processor.

[0540] An instance system may provide a platform comprising an isolated workspace, wherein a processor of the server sets channel information to be provided to a first computing system external to the platform based on the platform. The first computing system may be a partner system (or client system).

[0541] The processor of the server may receive data collected in relation to the first computing system according to the set channel information, and provide the collected data to a second computing system utilizing the isolated workspace. Here, the second computing system may be a client system (or partner system).

[0542] Meanwhile, the processor of the server can provide channel information set based on the platform to a first computing system external to the platform.

[0543] The processor of the server may receive data collected in relation to the first computing system based on the provided channel information, store the collected data in a storage medium, and provide the stored data to a second computing system external to the platform.

[0544] Here, the first computing system may be a partner system (or client system), and here, the second computing system may be a client system (or partner system).

[0545] For an example of an application service provider, see the detailed examples of instance systems and channel setup above.

[0546] If the above embodiment is performed as a program based on an instance system, the program may set channel information to be provided to a first computing system external to the platform based on the platform, receive data collected in relation to the first computing system according to the set channel information, and provide the collected data to a second computing system using the isolated workspace.

[0547] In addition, the program may provide channel information set based on the platform to a first computing system external to the platform, receive data collected in relation to the first computing system based on the provided channel information, store the collected data in a storage medium, and provide the stored data to a second computing system external to the platform.

[0548] Here, the first computing system may be a partner system (or client system) and the second computing system may be a client system (or partner system).

[0549] According to the disclosed embodiment, information can be transmitted and received without causing security issues within a client or partner, and patches or upgrades can be easily performed using agents installed within a client or partner outside the platform.

[0550]

[0551] FIG. 29 is a diagram disclosing an embodiment of running an adapter in a workspace according to an embodiment.

[0552] To facilitate the development of adapter packages, the present invention provides an easy construction method for various standard link protocols and aims to provide an app store (1510) for exchanging adapter packages among developers.

[0553] Here, the app store (1510) may include an adapter package sales unit (1501) and an adapter package purchase unit (1502). The app store (1510) may refer to the above-described embodiment and may represent a platform where developers can upload adapter packages and users can purchase and download adapter packages. This will be described later. In one embodiment, a developer must obtain approval from an administrator to sell an adapter package through the app store (1510).

[0554] As described above, the client (here, the client may include both developers and users, 100) can create, execute, and modify various packages in the 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.

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

[0556] In one embodiment, when running an adapter, it may interact with the platform described above to resolve the requirement. That is, the platform depicted in the drawing may be provided through the application service manager described above, and is not a concept included in the workspace (1500, 3000).

[0557] The services provided by the platform can support the following functions:

[0558] The Message Box service represents a service that retrieves and stores sent and received documents.

[0559] Communication Protocol Access Services represent services for accessing external communication protocols. For example, these represent services for HTTP / HTTPS and FTP access.

[0560] The configuration repository service represents a service that stores and retrieves the configuration required for the adapter to run.

[0561] This has the advantage that platform service providers can 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.

[0562] Additionally, users can build various standard linkage protocols through the process of purchasing, installing, configuring, and running the created adapter, and from the perspective of adapter developers, there is an advantage in that they can generate revenue by developing and selling adapters.

[0563]

[0564] Figure 30 is a drawing disclosing an example of an adapter package.

[0565] A package is a bundle of programs (code files or configuration files) that are installed and run in a workspace. It includes adapter packages, integration packages, and resource packages. Integration packages and resource packages are described above.

[0566] An adapter package represents a package that supports the use of various protocols and platform-specific services for integration. Typically, adapter packages are configured web-based using platform-specific services, and the configured information (channels) can be used in the integration package. This is described above.

[0567] In one embodiment, the adapter package may include the following adapters, which allow for addressing a wide variety of requirements through the adapter package described below.

[0568] 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.

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

[0570] The third adapter package (1520c) may include a web scraping adapter. Here, the web scraping adapter represents an adapter for scraping functionality in a web service that is provided only as a web service and not through standard communication.

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

[0572] Of course, the adapter package may include other adapters developed by developers through the workspace in addition to the adapters described above.

[0573]

[0574] FIG. 31 is a diagram illustrating an example of running an adapter in a workspace according to an embodiment.

[0575] In one embodiment, an application service manager that develops an adapter and a workspace that runs the developed adapter can be provided (S210).

[0576] Developers can develop adapters using the Application Service Manager described above. They can then run the developed adapters in the development workspace to test them.

[0577] More specifically, developers can develop and version-up adapter packages, and to do this, developers can install adapter packages into a workspace and run adapters.

[0578] At this point, the development workspace, where the developed adapter is run for testing, and the operational workspace, where the adapter is actually used, can be separated. The distinction between the development workspace and the operational workspace is a logical concept.

[0579] In one embodiment, an app store for selling and purchasing the developed adapter package may be provided (S220).

[0580] Developers can include their developed adapters in adapter packages and sell them through app stores. In one embodiment, the developer of an adapter package can grant developer privileges to other users.

[0581] In particular, developers of adapter packages can develop custom classes and register them as components in the application context described below. At this time, developers can reference other components and even web services (Rest, Servlet classes).

[0582] Developers can designate a given class as a Singleton Component. From there, the component can be referenced through the Application Context from other components, Rest, or Servlet Services.

[0583] Users can purchase adapter packages available for sale within the App Store.

[0584] In one embodiment, a workspace can be provided that installs a purchased adapter package and runs an adapter included in the adapter package (S230).

[0585] Users can install adapter packages in their workspaces and install and run adapters contained within the adapter packages. In one embodiment, users who purchase adapter packages can only install them in their own workspaces. This is because, as described above, each user uses a separate workspace.

[0586]

[0587] FIG. 32 is a drawing disclosing an example of an adapter using a framework according to an embodiment.

[0588] The Core can provide the following services, corresponding to the framework described above.

[0589] (1) Configuration Repository: This can store and manage configuration information. This allows the system to store configuration data and provide access to necessary configuration information.

[0590] (2) Distributed Task Service: This service can process and manage tasks in a distributed environment. This allows for task distribution and status tracking across multiple nodes or systems.

[0591] (3) Channel Registry: This registry can be responsible for registering and managing communication channels. This allows for the registration and use of channels for communication between different systems or packages.

[0592] (4) Message Box Service: Supports message-based communication. This provides functions such as message transmission, reception, storage, and routing, enabling asynchronous communication between various systems.

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

[0594] The adapter of the present invention can use the API to utilize the framework. That is, the adapter can utilize the core services through the API.

[0595]

[0596] The API can provide the following services:

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

[0598] (2) Task Service: This is a service interface for using functions related to task processing, and can provide task management functions such as task creation, status inquiry, and result return.

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

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

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

[0602] (6) File Watcher: An interface that handles file monitoring, can handle file change events, and perform necessary tasks.

[0603]

[0604] A user implement can provide the following services:

[0605] (1) Web Service: This is the implementation code used by users to develop web-based services, and the settings required for the adapter to run can be provided through a web interface.

[0606] (2) User Classes: User-defined classes that developers write to implement their own logic. They can implement specific domain or business logic by utilizing the functions of the Core or API.

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

[0608]

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

[0610] The Application Context is a component included in the framework and can contain service APIs for developing adapter packages. For example, the service APIs can include WorkspaceIdentity, MessageAccessService, MessageSlotInfoService, ConfigurationService, TaskService, ChannelAccessService, and FileAccessService.

[0611] In one embodiment, the developer of an adapter package can specify a method to be executed according to the adapter package's life cycle. The developer can use annotations related to the life cycle. For example, a specific method can be specified to be executed when the package starts or ends. This will be described later.

[0612] Additionally, services registered in the Application Context can interact with user classes registered as beans. For example, user implementation classes registered as beans may include FileWatcher, TaskImple, ChannelProcessorImple, and other user-defined classes. These classes implement specific functions or business logic of the application and are registered as beans in the application context so that they can be used by other components. This allows the framework to manage instances of user classes and create and use objects required by the application.

[0613] In one embodiment, the Application Context registers a user component as a bean so that it can be referenced in a web service (e.g., Rest, Servlet). In one embodiment, when referencing a user component in a web service, the reference is made directly through the Application Context. The method is as follows.

[0614] Method:

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

[0616] - WorkspaceIdentity getWorkspaceId(): See WorkspaceIdentity

[0617] - String getPackageId(): Returns the package ID value

[0618] At this time, Rest API can be implemented through JAX-RS API. To do this, register REST service with @RestService Annotation and access it with / pkg / {workspace_install_path} / {package_install_path} / rest / {path).

[0619] Additionally, the Servlet API can be implemented through the javax.servlet API.

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

[0621]

[0622] 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 a class used for workspace authentication when the adapter package uses the Cloud EDI service. WorkspaceIdentity is required when using the API provided by the Cloud EDI platform. Here's how.

[0623] Method:

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

[0625] - getTicket(): Returns a ticket that can authenticate the workspace to which the package belongs.

[0626]

[0627] The following describes TaskService. TaskService can provide functionality related to distributed task scheduling. TaskService can register tasks in a distributed environment and schedule them for periodic execution. Tasks registered by the distributed task service can be executed at a specified time or based on an event.

[0628] In other words, TaskService can be used in adapter packages to register and cancel specific tasks with the distributed scheduler. Users can implement the Task interface, and the distributed scheduler can support Cron and Secondary methods. The methods are as follows.

[0629] Method:

[0630] - register(TaskConfig config, Task task): Register a task to the distributed scheduler.

[0631] - return: task unique ID)

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

[0633]

[0634] The MessageBoxAccessService is described below. MessageBoxAccessService accesses EDI message boxes to enable document transmission and reception. For example, it can access cloud-based message boxes to transmit data and process received data. Here, MessageBox represents an API that accesses the message box repository to store, retrieve, or delete documents. The method is as follows:

[0635] Method:

[0636] - send(): Save the document to MessageBox

[0637] - queryPendingMessageList(): Returns a list of message records (message headers) in the transmission waiting state (TBDL, WAIT) in the given slot / path name.

[0638] - receivePayload(): returns the message body

[0639] - updateMessageStatus(): Change message status

[0640] - deleteMessage(): Delete message

[0641]

[0642] The description of MessageSlotInfoService is as follows. MessageSlotInfoService corresponds to a service that contains slot information for message boxes. The method is as follows.

[0643] Method:

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

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

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

[0647]

[0648] The following describes ConfigurationService. ConfigurationService corresponds to a service that accesses the Config Repository to retrieve, modify, and delete configuration information. This allows for managing configuration data and accessing necessary configuration information. ConfigurationService represents an API that allows a package to directly access the Config Repository, read, modify, or delete its configuration. The method is as follows:

[0649] Method:

[0650] - 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 retrieves the configuration information required for the configuration screen UI in Web Admin.

[0651] At this time, it is recommended to use FsWatchSystem to apply the setting values ​​in the adapter package.

[0652] - create(WorkspaceIdentity, String packageId, ConfigNode node): Create a configuration node

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

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

[0655]

[0656] The FileWatchSystem is described below. FileWatchSystem can monitor file changes in a given path or directory and provide functionality to perform necessary actions. More specifically, FileWatchSystem periodically monitors directories in registered paths, detects file creation, modification, and deletion, and can interface with them through registered FsWatcher instances. Here, FsWatcher instances can implement actions to be taken when file changes are detected within the path. For example, the method is as follows:

[0657] Method:

[0658] - init(Set <file>fset, String path): When FsWatcher is first registered, it passes the file set in the path registered as a parameter.

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

[0660]

[0661] The FileAccessService is described below. FileAccessService can be used to access files by accessing an FTP server within Cloud EDI or an external FTP server. The method is as follows:

[0662] Method:

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

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

[0665] - list(String workspaceId, String serviceName, String folderPath, String pattern): Retrieves a list of files matching the GLOB pattern among the files in the target path.

[0666] - delete(String workspaceId, String serviceName, String folderPath, String filename): Deletes the file in the target path.

[0667]

[0668] ChannelAccessService is a component that provides distributed channel access services in response to channel requests. A specific process can subscribe to a channel and process messages or events received from it. This allows data to be transmitted through the channel and received and processed. The method is as follows.

[0669] Method:

[0670] - create(String channelId, String channelName): Pre-create a channel in the workspace.

[0671] - subscribe(ChannelProcessor processor): Register an interface to process channels as the default channel of the package.

[0672] - Subscribe(String channelId,ChannelProcessor processor): Register a channel with a specific channel ID.

[0673] - unsubscribe(): Unregister the package from the default channel.

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

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

[0676]

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

[0678] 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 through settings.

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

[0680] This drawing illustrates an embodiment of providing an EDI service using the first adapter package (324) described above. For a client (310) to transact 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.

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

[0682] 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.

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

[0684] Thereafter, the EDI information may 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) may perform the role of a router as described above.

[0685] In one embodiment, the first adapter package (324) may store EDI information including the Original EDI Message (313) in the first partner outbox within the message box service (2110) based on information received from the coordinator (1100). In addition, the first adapter package may transmit the EDI information including 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 lookup the adapter channel registry.

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

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

[0688] Thereafter, the message box service (2110) can transmit EDI information including 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). In addition, the message box service (2110) can transmit EDI information including 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 customer's trading partners. This is because the customer (client) can exchange documents with multiple partners.

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

[0690] Accordingly, clients (310) and partners (320) can easily use application services such as EDI services according to the disclosed embodiments, and can easily conduct 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 transaction counterparty.

[0691] Additionally, clients (310) or partners (320) can develop or utilize adapter packages such as the above in their workspaces and link them to the integrated package (1380). The embodiment provides a simple interface for developing such packages and linking them to existing packages, and the developed packages can also be sold, shared, or provided separately.

[0692]

[0693] FIG. 35 is a drawing disclosing an example of a framework for developing an adapter package according to an embodiment.

[0694] In one embodiment, an application service manager for developing an adapter package may be provided (S240). To this end, the application service manager may provide a developer tool to the developer. For a description of the application service manager, refer to FIGS. 2 to 4.

[0695] In one embodiment, a first workspace for testing a developed adapter package may be provided (S250). Here, the first workspace corresponds to a development workspace. For a detailed description of the development workspace, refer to FIGS. 2 to 4 and FIG. 9.

[0696] In one embodiment, a second workspace for executing the developed adapter package may be provided (S260). Here, the second workspace corresponds to the operational workspace. A client (developer or user) can execute the adapter package in the operational workspace to utilize various application services. Here, the application service may include at least one of a message box service, a communication protocol access service, and a configuration storage service. For details, refer to FIGS. 11, 32, and 33.

[0697] Afterwards, the application service provision method can upload the developed adapter package to the app store. In one embodiment, the developed adapter package may or may not be uploaded to the app store based on administrator approval. This will be described in detail below. Users can download the uploaded adapter package from the app store and run and operate the downloaded adapter package in their isolated workspace.

[0698]

[0699] FIG. 36 is a drawing disclosing an example of an application service providing device according to an embodiment providing an application package on an app store platform.

[0700] An application service providing device according to an embodiment of the present invention may include an instance system (1000) and a manager system (2000).

[0701] The manager system (2000) can provide an environment in which a client (110) can develop an application package. That is, a user (third party, developer) client (110) can develop an application package through the environment provided by the manager system (2000) according to his / her own needs or for sales purposes.

[0702] In one embodiment, an application package may include at least one of an adapter package, an integration package, and a resource package. In this case, the adapter package may include a protocol adapter for linking or a software package with multiple functions. In addition, the integration package may include a software package with a practical integration flow. The integration package may be modified to suit the requirements of the client (120) after being purchased by the client (120). In addition, the resource package may include a package that separately packages resource files additionally required for the operation of the adapter package.

[0703] The client (110) can test the developed application package through the development workspace (3000) and send an upload request including the tested application package and additional metadata to the application service manager (2100) of the manager system (2000).

[0704] The application service manager (2100) analyzes the various predefined approval criteria for the application package to determine whether the application package is suitable for sale and approves its upload. If approved, the application package becomes available for purchase by clients (120) in the app store.

[0705] A client (120) can send a purchase request for an application package to the application service manager (2100) to purchase the corresponding application package that is available for purchase.

[0706] A client (120) can install a purchased application package in its workspace (1520). The client (120) can configure the installed application package according to its requirements and actually operate it.

[0707]

[0708] Figure 37 is a flowchart disclosing another embodiment of a method for providing application services according to an embodiment.

[0709] A request for uploading an application package to the app store is received from a first client (S301).

[0710] In one embodiment, the upload request may include an application package and metadata about the application package. For example, the metadata may include at least one of the following: a package name, a package description, a package type, package version information, a payment type (e.g., one-time payment, subscription, installment payment), a sales price by national currency, registrant user information, and a registration time.

[0711] According to the above upload request, upload of the application package to the app store is approved based on predefined approval judgment conditions for the application package (S303).

[0712] In one embodiment, if at least one of the source code for the application package, the list of hosts requesting external access permission for the application package, the external library used for the application package, and the file size of the application package satisfies the predefined approval judgment condition, the upload of the application package to the app store may be approved.

[0713] In one embodiment, if there is no security vulnerability in the source code for the application package or the source code does not contain malicious code, the upload of the application package to the app store may be approved.

[0714] In one embodiment, if an application package includes an adapter package, the socket connection and file access permissions for the adapter package may be restricted. Accordingly, for adapter packages that require access to external networks for specific purposes (e.g., mail senders, web scrapers, etc.), a list of hosts requiring external access authorization may be checked, and if any of the external hosts included in the list are externally accessible, the application package may be approved for upload to the app store. In this case, the list of hosts requiring external access authorization may be included in a resource file within the adapter package.

[0715] In one embodiment, for an application package to be installed and function properly, external libraries referenced by the application package must be provided by the platform environment in which the application package is installed. In this case, if an external library is not provided in the platform environment, additional procedures must be performed to enable the application package to reference it. Therefore, the dependency on the referenced external library can be checked. Therefore, if the external library can be used by the application package, the application package can be approved for upload to the app store.

[0716] In one embodiment, if the file size of the application package does not exceed a threshold, the application package may be approved for upload to the app store. Specifically, the file size of the application package may be checked to ensure that it does not contain unnecessary resources and does not excessively consume resources in the platform environment.

[0717] The above-mentioned approved application package is provided in the above-mentioned app store (S305).

[0718] In one embodiment, the approved application package can be registered in the app store based on metadata about the application package, and the application package can be provided upon a purchase request for the application package.

[0719]

[0720] Figure 38 is a flowchart disclosing another embodiment of a method for providing application services according to an embodiment.

[0721] A purchase request for the above application package is received from a second client (S311).

[0722] In one embodiment, a purchase request may be received from a second client for an application package that is uploaded to an app store and available for purchase.

[0723] According to the above purchase request, the application package is provided to the second client (S313).

[0724] In one embodiment, upon a purchase request, the application package may be provided to a second client if the sale of the application package is approved based on the application package for the purchase request and the package description and terms of sale included in the metadata of the application package.

[0725] In one embodiment, the provided application package may be installed in the workspace of the second client. That is, the application package purchased by the second client may be installed in the workspace, which is the executable area of ​​the second client. In one embodiment, the installed application package may be executed and operated according to the configuration information of the second client.

[0726]

[0727] FIG. 39 is a drawing disclosing an example of an application service providing device according to an embodiment providing a service for an application package.

[0728] An application service providing device (400) according to an embodiment of the present invention can provide a Software as a Service (SaaS) service to a client (100) that provides an internal system to at least one customer company and to at least one partner (200).

[0729] For example, internal systems may include, but are not limited to, enterprise resource planning (ERP), customer relationship management (CRM), and warehouse management system (WMS).

[0730] In one embodiment, the client (100) can provide a service through an internal system to at least one customer company (not shown) connected to multi-tenancy.

[0731] In one embodiment, the application service providing device (400) may provide an application package to a client (100) in the form of an API and allow the client (100) to use the service by grafting it onto the internal system of the client (100).

[0732] In one embodiment, a client (100) and an application service providing device (400) can send and receive messages. At this time, the client (100) can send a message to the application service providing device (400). For example, the message may include an Electronic Data Interchange (EDI) message.

[0733] The application service providing device (400) can identify a client (100) based on an authentication key corresponding to the client (100) included in a message, and provide a service for an application package to the identified client (100). In one embodiment, the authentication key can include an API (Application Programming Interface) key corresponding to the client (100) for the application package.

[0734] According to the present invention, API keys and asymmetric key encryption (Rivest-Shamir-Adleman, RSA) methods can be applied to provide multi-tenancy.

[0735] Accordingly, according to the present invention, the application service provider (400) can connect to EDI / API with service providers that provide enterprise services such as ERP, CRM, and WMS to multiple companies. Therefore, when multiple suppliers are connected to a single company, such as domestic or international distributors or automobile manufacturers, and use EDI / API, the single connected company can be used by multiple suppliers in common.

[0736]

[0737] FIG. 40 is a drawing disclosing another example in which an application service providing device according to an embodiment provides a service for an application package.

[0738] The client (100) may include an agent (350) including an API providing unit (610), a message management unit (620), an encryption / decryption unit (630), a transmission / reception unit (640), a management screen unit (650), and a database (660). In this case, the API providing unit (610) may provide an API for transmitting and receiving data and monitoring so that it can be used in an internal system (e.g., an ERP system).

[0739] In addition, the management screen (650) can manage API keys for each client using the internal system and display a screen for monitoring the transmission and reception history of messages.

[0740] In one embodiment, the application service providing device (400) may provide a user interface (UI) for managing authentication keys and monitoring message transmission and reception history to the client (100). Through this, the user of the client (100) can view the history of message transmission and reception, document processing, and the contents of transmitted and received documents through the management screen (650). For example, the processing history, status, and processing time of a document may be viewed.

[0741] The message management unit (620) can encrypt and delete messages according to message management and storage policies. Furthermore, the message management unit (620) can store message and transmission / reception history information in a database (660).

[0742] The encryption / decryption unit (630) can perform encryption / decryption on data, and perform digital signature and verification on the data. For example, the encryption / decryption unit (630) can perform encryption / decryption, signing, and verification based on the RSA encryption algorithm.

[0743] The transmitter / receiver (640) can transmit a message including data, an electronic signature, and an authentication key to the agent adapter (1350) of the application service providing device (400), and receive a message from the agent adapter (1350).

[0744] The transceiver (640) can obtain information from an internal system (e.g., an ERP system), convert it into data, and transmit it to the transceiver (710) of the agent adapter (1350), or convert data received from the transceiver (710) of the agent adapter (1350) and store it in the internal system.

[0745] In one embodiment, the application service providing device (400) may include an agent adapter (1350) and a manager server (2100). The agent adapter (1350) may include a transceiver (710), a customer identification unit (720), an encryption / decryption unit (730), and a format conversion unit (740).

[0746] The transceiver (710) can receive a message from the agent (350) of the client (100) or transmit a message to the agent (350). In one embodiment, the transceiver (710) can store a message received from the transceiver (610) of the agent (350) in a message box (2110) within the manager system (2100), or can cause the transceiver (610) of the agent (350) to receive various pieces of information set in the agent adapter (1350) and store the information in the message box (2110). The customer identification unit (720) can identify a customer receiving a service through the internal system of the client (100) using an authentication key included in the message.

[0747] The encryption / decryption unit (730) can perform encryption / decryption on data, and perform electronic signature and verification on the data. For example, the encryption / decryption unit (730) can perform encryption / decryption, signing, and verification based on the RSA encryption algorithm. The format conversion unit (740) can convert the data format of the decrypted data. The transmission / reception unit (710) can transmit a message with the converted data format to the partner (200).

[0748]

[0749] Figure 41 is a flowchart disclosing an example of a method for providing application services according to an embodiment.

[0750] A message containing the customer's authentication key for the client's (100) internal system is received from the client (100) (S401).

[0751] In one embodiment, the message may further include data encrypted using the public key of the application service providing device (400) based on the RSA encryption algorithm and an electronic signature signed using the private key of the client (100) based on the RSA encryption algorithm. For example, the data may include data for a transaction, such as EDI data.

[0752] The customer is identified based on the authentication key (S403). In one embodiment, the authentication key may include an API key indicating the customer's identification information. For example, the API key may include a unique code for identifying the customer.

[0753] In one embodiment, based on an authentication key table pre-stored in the application service providing device (400), a customer can be identified by comparing the authentication key list for the customer included in the authentication key table with the authentication key included in the received message.

[0754] Services are provided based on messages to identified clients (S405). In one embodiment, encrypted data can be decrypted, the decrypted data format can be changed, and the data can be transmitted to partners. In other words, according to the present invention, a client (100) that provides services to multiple clients through its internal system can provide affiliate services.

[0755]

[0756] Figure 42 is a flowchart disclosing an example of a method for providing an application service according to an embodiment of the present invention.

[0757] Encrypted data is decrypted using the private key of the application service providing device (400) based on the RSA encryption algorithm (S411). In one embodiment, data encrypted using the public key of the application service providing device (400) based on the RSA encryption algorithm can be decrypted using the private key of the application service providing device (400). In one embodiment, the decrypted data can be hashed to generate a hash value.

[0758] Using the public key of the client (100) based on the RSA encryption algorithm, the electronic signature for the decrypted data is verified (S413). In one embodiment, the electronic signature signed using the private key of the client (100) based on the RSA encryption algorithm can be verified using the public key of the client (100). In one embodiment, it can be confirmed that the hash value generated by the client (100) hashing the data before encryption matches the hash value generated by hashing the decrypted data.

[0759] Based on a pre-stored schema and a pre-stored mapping script for the data, the data format of the decrypted data is changed (S415).

[0760] In one embodiment, for EDI service, documents between two trading parties must be mapped, bytes or strings contained in data (e.g., EDI data) according to a pre-stored schema must be decoded and converted into decoded data, and schemas may be mapped to each other based on the schemas of the data and the data to be converted based on a mapping script, and the data format may be changed.

[0761] The data format is changed and transmitted to the partner (200) (S417). In one embodiment, according to the present invention, data related to inter-business transactions can be standardized and transmitted between the parties to the transaction, thereby conveying information. In this case, the client (100) providing the internal system service can efficiently connect to a multi-tenant client without individually building an EDI system for each client company.

[0762]

[0763] Figure 43 is a drawing disclosing an example of an application service providing device converting a data format according to an embodiment.

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

[0765] 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 the agent adapter (1350) installed in the worker node. The mapping adapter (1370) may unmarshall the source document data of the client (100) and output it as target document data mapped with information required by the partner (200).

[0766] Accordingly, the 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).

[0767] The agent adapter (1350) may include a transceiver (810). The transceiver (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).

[0768] 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).

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

[0770] 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 a message box (2110) and transmit it to the agent (450) of the partner (200).

[0771]

[0772] FIG. 44 is a drawing disclosing an example of an application service providing device according to an embodiment converting a data format using a schema and a mapping script.

[0773] 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 the first data format or the first data structure.

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

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

[0776] 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. 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.

[0777] In one embodiment, the mapping unit (830) may perform mapping to convert source structure data into target structure data using structure information including the structure (tree) and name (Identifier) ​​of the source document data.

[0778] In one embodiment, at least one of a source schema, a mapping script, or a target schema may be included and stored in a mapping program. The mapping unit (830) may convert source structure data into target structure data based on the mapping program. In this case, the annotation information of the source schema and the target schema is used only for serialization and deserialization, and is not used in the mapping program. This is because the mapping based on the mapping script is intended to focus only on mapping data between schema nodes of the source schema and the target schema.

[0779] 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 only for mapping regardless of serialization and deserialization, and the annotation information of the schema is used only for serialization and deserialization, thereby effectively supporting domain-specific language (DSL)-based mapping.

[0780] 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.

[0781] 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 the second data format or the second data structure. That is, for example, the target document data may have a different data format from the source document data. Furthermore, for another example, the target document data may have the same data format as the source document data but a different data structure.

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

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

[0784] Therefore, according to the present invention, a domain specific language (DSL) can be used to define a schema for serializing / deserializing documents of various data formats by utilizing annotation information.

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

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

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

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

[0789]

[0790] Figure 45 is a diagram disclosing an example of deserialization and serialization based on a schema according to an embodiment.

[0791] In one embodiment, deserialization, which converts document data into structured data, may be performed 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 with 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.

[0792] In one embodiment, serialization, which converts structured data into document data, may be performed based on a schema for the document data. In this case, serialization may be referred to as marshaling or a term with an equivalent technical meaning. In one embodiment, the structured data for serialization may include target structured data, and the document data may include target document data.

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

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

[0795] In one embodiment, the annotation information may correspond to a data type and include information used when recognizing (parsing, deserializing) the data from the document data. For example, @XmlElement(name=”” may represent an annotation, and the XmlElement described after @ may represent the name of the annotation and include an element named name, the value of which may be “employee”.

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

[0797]

[0798] Figure 46 is a drawing disclosing an example of a mapping script according to an embodiment.

[0799] A mapping script may be used to transform source structure data into target structure data in the form of a target schema. In one embodiment, the mapping script may include at least one of sentence information representing the grammar of a programming language or expression information representing a specific result value.

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

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

[0802] Additionally, expression information can specify where to get the value to use, and can represent an expression that is converted to a single value through evaluation. For example, expression information can include, but is not limited to, Constant, Path, Custom Function, and LoopVar, and can include various expression information. In this case, Constant can be represented by directly specifying a string or number. Path can represent a specific path of the source. Custom Function can represent a function created by the user. LoopVar represents a variable of a Loop iteration statement, and can represent a LoopVar such as #i, for example.

[0803] In one embodiment, a mapping script may be included in a mapping program. In one embodiment, such a mapping script may be defined in BNF, which is a grammar expression that can define the syntax of a programming language.

[0804]

[0805] Figure 47 is a flowchart showing an example of a method for providing an application service according to an embodiment of the present invention for converting a data format.

[0806] Receive source document data having a first data format from a client (100) (S501). For example, the first data format may include at least one of a first data format or a first data structure. In this case, the first data format may include EDI, a flat file, JSON, or XML format.

[0807] For example, the EDI format may include, but is not limited to, the standardized X.12 or EDIFACT format and may include various formats. In one embodiment, if the source document data is EDI data, the source schema may use the EDI format of the SEF standard as the EDI schema or an EDI format such as EXF.

[0808] Additionally, a flat file can refer to a file containing records without structural relationships. For example, a flat file might contain a text document with all document processing or other structural characters or markup removed.

[0809] Source document data having a first data format is converted into target document data having a second data format (S503).

[0810] In one embodiment, based on a pre-stored source schema for the source document data, the source document data can be converted into source structure data, based on a pre-stored mapping script for the source structure data and the target structure data, the source structure data can be converted into target structure data, and based on a pre-stored target schema for the target document data, the target structure data can be converted into target document data having a second data format.

[0811] In one embodiment, specifically, deserialization may be performed to convert source document data having a first data format into source structure data based on at least one of structure information about the source document data included in a pre-stored source schema or annotation information about the structure information.

[0812] In one embodiment, mapping may be performed to convert source structure data into target structure data based on at least one of structural information about source document data included in a pre-stored source schema, statement information or expression information of a programming language included in a pre-stored mapping script, or structural information about target document data included in a pre-stored target schema.

[0813] In one embodiment, serialization may be performed to convert target structure data into target document data having a second data format based on at least one of structural information about the target document data or annotation information about the structural information included in a pre-stored target schema.

[0814] Target document data in a second data format is transmitted to the partner (200) (S505). For example, the second data format may include at least one of a second data format or a second data structure. In this case, the second data format may include, but is not limited to, EDI, flat file, JSON, or XML formats, and may include various other formats.

[0815]

[0816] Below, an embodiment is disclosed in which a client or partner can develop a required application based on an application package downloaded from a workspace.

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

[0818] For example, if a client develops an application that delivers EDI information as a service, the client can develop a mapping program that maps standardized transaction information with its partners and provide information to them based on this program. Alternatively, the client can sell the developed mapping program itself on the Manager System platform.

[0819] While this example illustrates a mapping program, clients or partners may require different information or document mappings depending on the type of business they operate, the nature of their transactions, etc. Here, mapping refers to the process of converting data (source) with schema A into data (target) with schema B. The schema represents the data structure, with nodes with different names forming a hierarchical structure.

[0820] Because these types of businesses are so diverse, the examples herein disclose examples that make it very easy for users to develop mapping programs that can map EDI information.

[0821] The platform according to the embodiment can provide an environment and interface for developing a mapping program, which are disclosed in detail as follows.

[0822]

[0823] FIG. 48 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0824] 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).

[0825] Here, the development tool palette (901) may include graphic blocks corresponding to the structure 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 such as “Statements”, “MAP”, “If”, “Then”, “Loop for”, “LoopVar”, “LoopVar++”, and “Match” used in the mapping program. However, the functions included in this drawing are only examples, and it is to be understood that other functions may be included.

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

[0827] For example, if the user interface receives an input signal (903a) from the user to select a graphic block of a first function (e.g., a “Statements” block) and then drag and drop 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 only an example and may include other preset input signals received from the user.

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

[0829] Thereafter, when the user interface receives an input signal (903b) for selecting a graphic block of a second function (e.g., a “LoopVar” block) from the user and then dragging and dropping it into the development GUI code area (902), the graphic block of the second function can be output from 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.

[0830] In addition, the development GUI code area can output the input box of the parameter included in the graphic block of the second function as it is. Referring to the "LoopVar" block described above, the "LoopVar" block in the development tool palette is a block that declares a 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 boxes for the parameter (variable name, initial value), the development GUI code area can also output the parameter input box as it is while outputting the "LoopVar" block.

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

[0832] Thereafter, when the user interface receives an input signal (not shown) from the user to select a graphic block of a third function (e.g., a “Loop for” block) and then drag and drop it into the development GUI code area (902), the graphic block of the third function can be output from 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, following the second function.

[0833] In this way, 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 of allowing the user to define a mapping program relatively easily even if he or she is not familiar with development scripts.

[0834]

[0835] FIG. 49 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

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

[0837] More specifically, the application service providing method can output source codes corresponding to functions output in the development GUI code area (902) on 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 in the development GUI code area (902) and inputs a parameter corresponding to the function, the application service providing method can generate and output source code (905) corresponding to the function and parameter on the development source code area (904).

[0838] In one embodiment, if a user directly modifies the source code (905), the user interface for developing a mapping flow 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).

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

[0840] However, developers who are not familiar with programming can easily access the user interface of the present invention, but developers who are familiar with programming may be more familiar with the source code method that compresses the program and may be more productive in the flow of a mapping program in which a large amount of mapping is repeatedly performed.

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

[0842] These GUI-based, easy-to-use mapping program definition tools enable developers to easily implement and manage complex mapping logic through a user-friendly interface and visual programming approach.

[0843]

[0844] FIG. 50 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

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

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

[0847] This 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).

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

[0849] 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 pop-up window for outputting source code corresponding to the development GUI code included in the mapping program area (906). Here, the source code area pop-up window may include the development source code area described above.

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

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

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

[0853] The source schema area (907) and the target schema area facilitate connections between source schema and target schema nodes.

[0854] Additionally, in one embodiment, the user interface may output a mapping line between nodes contained in the source schema and nodes contained in the target schema. This allows the user to visually determine whether a node in the source schema is mapped to a node in a target schema.

[0855] Additionally, in another embodiment, when the user interface receives an input signal for selecting a node included in the source schema and then dragging and dropping it to a node included in the target schema, the user interface can automatically output the corresponding mapping formula to the mapping expression area (909).

[0856] The mapping expression area (909) is an area that performs mappings between actual nodes. It is displayed when a mapping block is selected from the preceding blocks (Statements), allowing multiple mapping expressions to be inserted between each node. In other words, it corresponds to an area that sets detailed values ​​of the mapping expression. This will be described later.

[0857]

[0858] FIG. 51 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0859] The mapping expression 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 that allows the user to input a path, data type (e.g., String), function, and input value (Arguments) included in the mapping block on the mapping expression area (909).

[0860] Accordingly, the user can select a function block and choose one of the various functions used in the mapping block. The various functions used in the mapping block are described below.

[0861]

[0862] FIG. 52 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0863] 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).

[0864] As described above, the schema editing area (911) is an area where the user edits the schema used in the mapping flow, and an example is shown in this drawing. Here, the schema editing area (911) represents the structure of data and can represent a hierarchical structure of nodes with names. Here, each node can have a type such as Int or String. 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.

[0865] The annotation area (912) corresponds to an area for editing information required when the data is expressed as text (serialization) in addition to the hierarchical structure of the data. In addition, the annotation area (912) corresponds to an area for editing information required additionally when recognizing (parsing, deserializing) the data from text 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.

[0866] At this time, multiple comments can be added per node, and multiple comments with the same name cannot be added. Each comment can have several types depending on the document type (XML, JSON), and each comment can have unique properties (arguments).

[0867] For example, "ZmlAttribute" can indicate that when the node is serialized or deserialized to XML, it is an Attribute rather than an XML element.

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

[0869] These are later used in interactions with XML or JSON and can indicate which members should be handled in which way during the process of serializing or deserializing data.

[0870]

[0871] FIG. 53 is a drawing showing an example of providing a user interface for developing a mapping flow among the disclosed embodiments.

[0872] As described above, users can customize the functions included in the mapping block. When mapping programs attempt to map data from a source schema to a target schema, they can create the necessary functions and use them within the mapping expression area.

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

[0874] The function list area (915) represents an area where users can customize functions. For example, users can create functions and set the number of parameters for the functions. For example, the "concat" function is a function that concatenates strings, so it creates a new string by combining given strings. Accordingly, the "" function can receive two strings as parameters.

[0875] The + button included in the function editing screen allows users to add functions to the function list. Additionally, the edit button allows users to edit functions displayed in the function list area, and the delete button allows users to delete functions displayed in the function list area (915).

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

[0877] Here, each function performs its own specific task and can be utilized effectively in programming or data processing tasks. Users can create functions with different implementation methods and syntax depending on the actual language or context in use.

[0878]

[0879] Figure 54 is a drawing that discloses an example of a method for providing an application service among the disclosed embodiments.

[0880] In one embodiment, the application service providing method may provide a user interface including a development tool palette and a GUI block area (S601). For details, refer to the contents described above in FIGS. 15 to 19 and FIG. 48.

[0881] In one embodiment, the method for providing an application service may generate a first function block corresponding to the first graphic block upon receiving a signal from a user for selecting a first graphic block included in a development tool palette (S603). At this time, the development tool palette may include at least one graphic block. For example, the user may select one of at least one graphic block included in the development tool palette and then drag and drop it onto a development GUI code area.

[0882] In one embodiment, the application service providing method may output the generated first function block to the GUI block area (S605). At this time, the application service providing method may output the source code corresponding to the function block included in the GUI block area to the source code area. In one embodiment, when receiving a signal from the user to modify the source code, the application service providing method is characterized in that the function block being output to the GUI block area is modified in real time, and the function block is modified based on the source code. For this, please refer to the contents described above in FIG. 49.

[0883]

[0884] FIG. 55 is a drawing disclosing an example of an application service providing device according to an embodiment creating and testing an integrated package.

[0885] 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).

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

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

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

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

[0890] In one embodiment, an integrated package can be created based on an input signal from a user of the client (310) within the user interface by selecting a graphic block corresponding to a development tool and dragging and dropping it into the development GUI code area.

[0891] That is, according to the present invention, the integrated flow for an integrated package can be intuitively defined through a drag-and-drop method, and a form for entering the necessary parameters for each graphic block can be provided, enabling easy creation of an integrated package. The integrated package testing unit (923) can distribute the integrated package to the development workspace (3000) and perform integrated package testing and debugging.

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

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

[0894] Thereafter, 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 implement various requirements that the client (310) and the partner can transact with.

[0895]

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

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

[0898] Here, the development tool palette can include graphic blocks corresponding to the structure and functions of the language used in the integration package. That is, the development tool palette can include the entire list of keywords used in the integration package. For example, the development tool palette can include graphic blocks corresponding to the control structures and functions for each of the functions included in the integration package, such as connectors, services, processors, control flows, and modifiers, but is not limited thereto, and various functions can be implemented as graphic blocks. For example, a connector can include a "from" block (i.e., From Connector) that indicates the start of a route for an integration flow, and a "to" block (i.e., To Connector) that indicates an operation to the outside, such as calling a service, adapter, etc., or storing data. When an integration flow developed in a development environment is implemented, it can include.

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

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

[0901] In one embodiment, a To Connector corresponding to a 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.

[0902] In one embodiment, the To Connector's message box may include a user field feature. In this case, desired information within the integration flow may be stored in the user field, allowing for retrieval. In one embodiment, the user field may be added to the exchange header before storing the document in the message box. For example, when receiving a document from an agent, the user field may be added because the agent channel is identified by a user field (e.g., channelId).

[0903] When documents are saved to message boxes in an integrated flow, searches can be performed based on additional information such as control numbers.

[0904] A service can provide access to the integrated flow, or it can provide a current ControlNumber or memory cache service. A processor can define the processing of messages within the integrated flow. A control flow can provide looping and branching capabilities within the integrated flow. A modifier can provide functions such as getting and setting exchange values.

[0905] However, the functions included in this drawing are only examples and other functions may be included.

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

[0907] For example, when an application service providing device receives an input signal from a client (310) through 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 from the development GUI code area. At this time, the input signal for dragging and dropping is only an example and may include other preset input signals received from the client (310).

[0908] Here, the "from" block must be the top-level block of the integrated flow, which sequentially includes other blocks. That is, the "from" block corresponds to the block that includes the start and end of the integrated flow.

[0909] Thereafter, when the user interface receives an input signal from the user to select a graphic block of a second function (e.g., a “switch” block) and then drag and drop it into the development GUI code area, the graphic block of the second function can be output from 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.

[0910] Thereafter, 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 then drag and drop it into the development GUI code area, the graphic block of the third function can be output from 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.

[0911] In addition, the development GUI code area can output the input fields of the parameters included in the graphic blocks of each function as they are. Referring to the "from" block described above, the "from" block in the development tool palette is a block that defines the start of a route and must specify an object for retrieving data. Accordingly, the development GUI code area can also output the input fields of the parameters as they are while outputting the "from" block.

[0912] Afterwards, the user can directly input the parameter into the input field of the parameter of the "from" block. For example, the user can input the variable name as "MessageBox:AA_IN" in the "from" block. That is, the application service providing device can receive an input signal for the parameter of the graphic block output to the development GUI code area through the user interface. Accordingly, the development code can obtain data from MessageBox AA_IN.

[0913] In this way, the user interface for developing the integrated package of the present invention can provide visual assistance to users in structuring code in the development GUI code area using graphic blocks included in the development tool palette. This has the advantage of allowing users, even those unfamiliar with development scripts, to define the integrated flow with relative ease.

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

[0915]

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

[0917] An embodiment of the present invention will now be described in detail with respect to developing an integrated flow for performing mapping based on a stored mapping program. In particular, the drawing illustrates a user interface for setting information regarding the "toBlock" element among the input / output (From connect / To connector) coding elements of a route.

[0918] That is, a 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 a variable parameter for “”.

[0919] For example, a user can set a mapping file (mappingFile) of “toBlock” and set the source type (sourceType) and target type (targetType).

[0920] This diagram illustrates the process by which a channel called ame / AME_ADAPTER calls an adapter that performs mapping.

[0921] mappingFile represents a mapping program file saved 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.

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

[0923]

[0924] FIG. 58 is a drawing disclosing an example of providing a user interface for designating a development workspace in an embodiment.

[0925] In one embodiment, testing and debugging of routes for the integrated flow may be performed to verify the integrated flow. In this case, a development workspace (3000) may be designated in advance for testing and debugging. That is, the development workspace (3000) may be used for testing the integrated package, distinct from the client's (310) workspace (310).

[0926] In one embodiment, an integrated package may be deployed to a development workspace (3000) to test the integrated flow. For example, a deployment button may be displayed on a user interface provided to a client (310), and upon receiving a user input signal for the deployment button, the integrated flow may be deployed to the development workspace (3000).

[0927] Additionally, when the integrated package is deployed, the test button is activated, and a user input signal is received to initiate testing. That is, according to the present invention, testing can begin after preliminary preparations for testing are made through deployment of the development workspace (3000).

[0928]

[0929] FIG. 59 is a drawing disclosing an example of providing a user interface for integrated flow testing according to an embodiment.

[0930] In one embodiment, a user of a client (310) may select a route to perform a test by clicking on a from block, and the application service providing device may receive an input signal for the route from the client (310).

[0931] Thereafter, the user inputs mock data for conducting a test, and the application service providing device can receive an input signal for the mock data from the client (310). In one embodiment, the mock data may include at least one of information about the route, a header, a property, or a body of the data. In this case, the header and property may include key and value values.

[0932] In one embodiment, the mock data for testing can be exported or imported in file format (Export / Import).

[0933] Additionally, the user can specify a breakpoint by clicking on a graphic block corresponding to the breakpoint, and the application service providing device can receive an input signal for the breakpoint corresponding to the route from the client (310).

[0934] Additionally, the user can run debugging, and the application service provider can receive an input signal for debugging execution, thereby performing more detailed testing of the integrated flow from the from block corresponding to the start of the route to the breakpoint.

[0935] That is, according to the present invention, execution is temporarily stopped sequentially at each breakpoint selected by the user during debugging, and variable states at that point are checked, thereby efficiently identifying which part has a problem.

[0936] Therefore, according to the present invention, development productivity can be improved by performing unit tests and debugging using endpoint mocking and breakpoint functions in a test environment after distributing an integrated package.

[0937]

[0938] FIG. 60 is a drawing disclosing an example of a mock data input for an integrated flow test according to an embodiment.

[0939] In one embodiment, the target data may include response data from an output connector (to connector) that provides the output of the route to an external server of the integrated flow. For example, the external server may include an API server.

[0940] In one embodiment, when a user clicks "To block," the response data from the To Connector can be entered and mocked. If a flow that sends a request to an API server is being tested, the application service provider can perform the test by mocking the response data from the API server without actually calling the API server.

[0941] On the other hand, if no target data is specified, the application service provider can perform testing by sending a request to an actual endpoint and obtaining response data.

[0942]

[0943] Figure 61 is a flowchart showing an example of a method for providing an application service according to an embodiment of the present invention for converting a data format.

[0944] A user interface including a development tool for an integration flow for an integrated package is provided to the client (310) (S701). In one embodiment, an integration pattern is defined through a development tool for a GUI-based integrated package using a drag-and-drop graphic block coding method, and a user interface including a parameter input form according to the function of each graphic block is provided to enable easy definition of an integrated program.

[0945] An input signal for a development tool of an integrated flow is received from a client (310) (S703). In one embodiment, an input signal for selecting a graphic block corresponding to a development tool by a user of the client (310) within a user interface from the client (310) and dragging and dropping it into a development GUI code area may be received, and an input signal for a variable parameter of a graphic block output to the development GUI code area may be received.

[0946] An integrated package corresponding to an input signal is generated (S705). In one embodiment, after step S605, the generated integrated package is distributed to a development workspace (3000), and an input signal for at least one of a route for an integrated flow, mock data for the route, or a break point corresponding to the route is received from a client (310), and debugging for the route can be performed based on at least one of the route, mock data, or break point in the development workspace (3000). In one embodiment, the mock data may include response data of an output connector (to connector) that provides the output of the route to an external server of the integrated flow.

[0947] The integrated package is distributed to the workspace (1510) of the client (310) (S707). In one embodiment, the distributed integrated package can be executed for integration work.< / file> < / t>

Claims

1. In a computing system that manages a platform that provides clients with an isolated workspace where an application package runs, a step of receiving a channel request for transmitting and receiving information from the client; and A step in which the client provides a platform service for converting the application package in the workspace; Including, The steps for providing the above platform service are: A step of providing a user interface including a development tool palette and a GUI block area to the client; A step of generating a first function block corresponding to the first graphic block upon receiving a signal from the client for selecting a first graphic block included in the development tool palette by the user; and A step of outputting the generated first function block to the GUI block area; Including, Method of providing application services.

2. In paragraph 1, The steps for providing the above platform service are: A step of receiving a service request for the application package from the client; A step of performing authentication of the requested application package based on authentication information included in a software bundle related to the workspace; and A step of providing a service for the received application package according to the result of performing the above authentication; Including, Method of providing application services.

3. In paragraph 1, The steps for providing the above platform service are: A step for setting channel information to be provided to a first computing system external to the platform based on the platform providing the above-mentioned isolated workspace; A step of receiving data collected in relation to the first computing system according to the above-described set channel information; and A step of providing the collected data to a second computing system using the isolated workspace; Including, Method of providing application services.

4. In paragraph 1, The steps for providing the above platform service are: A step of providing an application service manager that develops an adapter package for the above client; providing a first workspace for testing the developed adapter package to the client; and A step of providing a second workspace for executing the developed adapter package to the client; Including, Method of providing application services.

5. In paragraph 1, The steps for providing the above platform service are: A step of receiving an upload request of the application package to the app store from the client; In accordance with the above upload request, a step of approving the upload of the application package to the app store based on predefined approval judgment conditions for the application package; and A step of providing the above approved application package in the above app store; Including, Method of providing application services.

6. In paragraph 1, The steps for providing the above platform service are: A step of receiving a message from said client including an authentication key of the client for the client's internal system; A step of identifying the customer company based on the above authentication key; and A step of providing a service based on the above message to the identified customer company; Including, Method of providing application services.

7. In paragraph 1, The steps for providing the above platform service are: A step of receiving source document data having a first data format from the client; A step of converting source document data having the first data format into target document data having the second data format; and A step of transmitting target document data having the second data format to a partner; Including, Method of providing application services.

8. In paragraph 1, The steps for providing the above platform service are: A step of providing a user interface including a development tool for an integration flow for the integrated package to the client; A step of receiving an input signal for a development tool of the integrated flow from the client; a step of generating the integrated package corresponding to the input signal; and A step of deploying the generated integrated package to the client's workspace; Including, Method of providing application services.

9. A database that stores data; and Including a processor for processing the above data, The above processor, In a computing system that manages a platform that provides clients with isolated workspaces in which application packages run, a channel request for sending and receiving information from said clients is received, Provides a user interface to the client, including a development tool palette and a GUI block area; Upon receiving a signal from the client for selecting a first graphic block included in the development tool palette by the user, a first function block corresponding to the first graphic block is generated, Outputting the first function block generated above to the GUI block area, Application service providing device.

10. In a computing system that manages a platform that provides clients with an isolated workspace where application packages run, a channel request for sending and receiving information is received from the client, The above client performs the step of providing a platform service for converting the above application package in the above workspace, The steps for providing the above platform service are: A step of providing a user interface including a development tool palette and a GUI block area to the client; A step of generating a first function block corresponding to the first graphic block upon receiving a signal from the client for selecting a first graphic block included in the development tool palette by the user; and A storage medium storing a computer-executable program that provides an application service, comprising: a step of outputting the generated first function block to the GUI block area;

Images