KR102276230B1 - Method for generating finite state machine, method for operating finite state machine, server and computer program for performing the same - Google Patents

Abstract

A method for generating a finite state machine is disclosed. The method includes allocating state information and action information to be executed in each of a plurality of states constituting a finite state machine, and providing event information for transition from the corresponding state to a subsequent state for each of the plurality of states. and generating a finite state machine using the assigned state information, action information, and event information. Here, the generated finite state machine may include event logic for generating a user event corresponding to a customer input through a service page or generating a machine event internally generated by the finite state machine.

Description

METHOD FOR GENERATING FINITE STATE MACHINE, METHOD FOR OPERATING FINITE STATE MACHINE, SERVER AND COMPUTER PROGRAM FOR PERFORMING THE SAME

The present invention relates to a method for generating a finite state machine, a method for operating a finite state machine, a server and a computer program for performing the same, and more particularly, to a method for generating a finite state machine based on a Moore machine, a method for operating a finite state machine, It relates to servers and computer programs that do this.

The number of Internet users is rapidly increasing thanks to the development of wired and wireless communication technology, and the Internet is a huge and efficient information storage and information provision medium connected with numerous computer networks around the world. is made possible in real time.

Due to the popular use of the Internet, many companies open their own sites and provide customers with various meaningful information, especially marketing information for their promotion.

As one of these marketing methods, an optimized landing page is being used a lot. Here, the landing page refers to a web page first viewed by a customer accessing via a search engine, advertisement, or the like.

In general, when a customer finds a desired web page on a landing page, if the menu or site search function is not faithful, the user gives up on finding the desired web page and leaves the site in many cases. In order to catch these churning customers and at the same time make it easy for them to move from the landing page to the destination page, the landing page is optimized with information to avoid unnecessary or confusing content as much as possible and guide the customer to achieve the purpose of their visit easily and quickly are doing

For example, in order to minimize customer churn, the landing page removes unnecessary content such as company history and greetings, and makes only one page with information that the customer may need.

On the other hand, the application event page, which contains contents such as promotions for customers and online events that the company wants to promote, has similar properties to the landing page in the nature that customers who access it through a search engine or advertisement see it for the first time.

Although there is no major change in the form of this application event page, it has properties that require frequent additions and changes. As an example, the application event page for providing the emoticon to the visitor may be configured such that the emoticon is paid only when the visitor visits the corresponding page. As another example, the application event page for providing the emoticon to the visitor may be configured so that the emoticon is paid only when the visitor visits the page and applies to win. As another example, the application event page for providing an emoticon to the visitor may be configured so that the emoticon is paid only when the visitor appreciates a certain work.

As such, if the purpose of the application event page is the same (for example, payment of emoticons in the example above), there is no major change in its form, but depending on the company's policy, marketing method, consumer response, etc., addition of the application event page, Changes in the form and structure of the application event page may occur frequently.

In particular, in a situation where the marketing environment changes rapidly, it is expected that the application event page will be added or changed frequently. If it is distributed with the code of the page, the risk is expected to be high.

For example, in relation to the development of the application event page, it is necessary to develop and operate a PC/mobile front-end, develop and operate a server, and manage the outsourcing schedule when outsourcing is necessary. And, when it is necessary to develop the application event page, it is necessary to collaborate with various departments such as planning, marketing, and CRM (Customer Relationship Management). However, if the code of the application event page and the code of the general page are distributed together in this process, inconvenience and difficulties are expected in the collaboration process of each department.

Therefore, in order to reduce this risk, it is necessary to provide an environment in which only the application event page can be separately worked by separating the application event page and the general page, and a plan for flexibly responding to addition and change of the application event page is required.

The present invention has been devised to solve the above problems, and an object of the present invention is to provide a method for generating a finite state machine that can flexibly respond to the operation of a service page, such as addition and change of a service page, and a server and computer program for performing the same is to provide.

In addition, an object of the present invention is a finite state machine operating method for determining the current state of a customer in a finite state machine, performing an action suitable for the customer's current state, and providing a service page suitable for the customer's current state To provide server and computer programs.

In order to achieve the above object, a method for generating a finite state machine by a finite state machine operating server according to an embodiment of the present invention is provided with state information and corresponding information for each of a plurality of states constituting the finite state machine. Allocating action information to be executed in a state, allocating event information for transition from the corresponding state to a subsequent state for each of the plurality of states, and using the allocated state information, action information and event information generating a finite state machine, wherein the generated finite state machine generates an event logic that generates a user event corresponding to a customer input through a service page or generates a machine event that occurs internally in the finite state machine. may include

In addition, generating a state block corresponding to each of the plurality of states using the allocated state information and action information, and forming a connection relationship between the plurality of created state blocks using the allocated event information The method may further include generating a state machine diagram and providing a manager interface including the generated finite state machine diagram to a terminal device of the manager.

In addition, the method may further include storing the service page to be displayed on the customer's terminal device by matching the corresponding state.

And, generating the finite state machine includes automatically setting the state to the end state when only event information for transition from the previous state to the state is assigned to the state, and the state from the state to the next state. When only event information for transition to a state is allocated, the method may further include automatically setting the corresponding state as the starting state.

In addition, the method further includes verifying the generated finite state machine, wherein the verifying includes whether the action assigned to the state is a previously registered action, and an argument of an API for executing the action assigned to the state. ) check, whether an event generated as a result of execution of an action assigned to a state is connected to a subsequent state, and whether essential items specified in the state are defined in the storage unit can be verified.

The method may further include displaying a state state block determined to be an error according to the verification on the finite state machine diagram to be distinguished from a state block having no error.

Also, the step of generating the finite state machine includes: detecting consecutive states, among a plurality of states, consisting of actions whose order does not affect each other, and generating events generated by each action of the detected states in all possible ways. The method may further include combining the number of cases and mapping an action to a new event.

The method may further include displaying, on the finite state machine diagram, which states among a plurality of states of a plurality of customers accessing the service page.

The method may further include distinguishing a connecting line representing the user event from a connecting line representing the machine event, and displaying the distinguishing line on the finite state machine diagram.

On the other hand, the finite state machine operation server according to an embodiment of the present invention for achieving the above object is a manager interface that provides an interface for creating a finite state machine, and the finite state based on a manager input through the manager interface. Allocating state information and action information to be executed in each of a plurality of states constituting the machine, and allocating event information for transition from the corresponding state to a subsequent state to each of the plurality of states, and the allocation and a generator for generating a finite state machine by using the state information, action information, and event information, wherein the generated finite state machine generates a user event corresponding to a customer input through a service page or generates the finite state machine It can contain event logic that triggers internally occurring machine events.

The generation unit generates a state block corresponding to each of the plurality of states by using the allocated state information and the action information, and establishes a connection relationship between the generated state blocks by using the allocated event information. and a diagram generator for generating the formed finite state machine diagram, wherein the manager interface may provide a manager interface including the generated finite state machine diagram to a terminal device of a manager.

In addition, the state in which the service page needs to be exposed among the plurality of states may further include a storage unit for matching and storing the service page to be displayed on the customer's terminal device to the corresponding state.

And, when only event information for transition from the previous state to the corresponding state is allocated to the state, the generating unit automatically sets the corresponding state to the end state, and provides an event for transition from the corresponding state to the subsequent state in the state. If only information is allocated, the corresponding state can be automatically set as the starting state.

The method further includes a verification unit that verifies the generated finite state machine, wherein the verification unit checks whether the action assigned to the state is a previously registered action, and an argument of an API for executing the action assigned to the state. It is possible to verify at least one of whether or not it has passed, whether an event generated as a result of execution of an action assigned to a state is connected to a subsequent state, and whether essential items specified in the state are defined in the storage unit.

The diagram generator may display the state state block determined to be an error according to the verification on the finite state machine diagram to be distinguished from the state block having no error.

In addition, the generating unit detects consecutive states composed of actions whose order does not affect each other among a plurality of states, and combines the number of all possible cases of an event generated by each action of the detected states to create a new It may further include a compounding unit for synthesizing an action by mapping to an event.

In addition, the diagram generating unit may display on the finite state machine diagram which state among a plurality of states a plurality of customers accessing the service page corresponds to.

Also, the diagram generating unit may distinguish between a connection line indicating the user event and a connection line indicating the machine event and display it on the finite state machine diagram.

Meanwhile, in a finite state machine operation method by a finite state machine operation server according to an embodiment of the present invention for achieving the above object, receiving request data from a customer terminal device; generating a user event, and changing the state of the customer from a first state that is the current state of the customer among a plurality of states constituting the finite state machine to a second state that is a subsequent state having a transition corresponding to the generated user event transitioning, detecting action information assigned to the second state, executing the action assigned to the second state based on the detected action information, and determining whether a machine event associated with the executed action occurs and determining the final state of the customer according to whether the machine event has occurred.

and when a machine event occurs in association with the executed action, transitioning the state of the customer from the second state to a third state, which is a subsequent state having a transition consistent with the generated machine event. can do.

In addition, if a machine event does not occur in connection with the executed action, determining the final state of the customer as the second state, detecting a service page matching the second state, and the detected service page It may further include the step of transmitting to the terminal device of the customer.

The finite state machine may include a user-generated event API that generates a user event corresponding to a customer input through the service page and a machine-generated event API that generates a machine event that occurs internally in the finite state machine.

In addition, the executing may include detecting an argument of an application program interface (API) for executing the action assigned to the second state, and corresponding to the second state based on the detected argument. It may include executing the API and changing parameters after the execution of the API corresponding to the second state.

On the other hand, the finite state machine operation server according to an embodiment of the present invention for achieving the above object, a request receiving unit for receiving request data from a customer terminal device, generates a user event corresponding to the received request data, Transitions the state of the customer from a first state among a plurality of states constituting the finite state machine to a second state that is a subsequent state having a transition consistent with the generated user event, and action information assigned to the second state and an execution unit that detects and executes an action assigned to the second state based on the detected action information, wherein the execution unit determines whether a machine event related to the executed action occurs, and the occurrence of the machine event Depending on whether or not it can determine the final status of the customer.

And, when a machine event occurs in connection with the executed action, the execution unit is configured to transition the state of the customer from the second state to a third state that is a subsequent state having a transition corresponding to the generated machine event. can

In addition, if the machine event does not occur in connection with the executed action, the execution unit determines the final state of the customer as the second state, detects a service page matching the second state, and the detected It may further include an interface providing unit for transmitting the service page to the terminal device of the customer.

The finite state machine may include a user-generated event API that generates a user event corresponding to a customer input through the service page and a machine-generated event API that generates a machine event that occurs internally in the finite state machine.

In addition, the execution unit detects an argument of an API (Application Program Interface) for executing the action assigned to the second state, and executes the API corresponding to the second state based on the detected argument and change the parameters after the execution of the API corresponding to the second state.

Meanwhile, a program according to an embodiment of the present invention for achieving the above object may be stored in a computer-readable recording medium to execute the method for generating a finite state machine.

In addition, the program according to an embodiment of the present invention for achieving the above object may be stored in a computer-readable recording medium to execute the finite state machine operating method.

According to various embodiments of the present invention described above, since a general page such as a customer center and a company introduction and a service page such as an application event page can be separately developed and distributed, the influence of services between each other can be minimized.

In addition, according to various embodiments of the present invention, by enabling the service page to be operated as a finite state machine-based tool, and by allowing the administrator to directly modify the template and publication management of the service page when necessary, development resources and schedules can be reduced. can

In addition, according to various embodiments of the present disclosure, by operating the processing of the service page as a separate server, it is possible to separate things that affect other services, such as a certificate and a contract page due to traffic, from each other.

In addition, according to various embodiments of the present disclosure, by providing a finite state machine-based tool suitable for operation of a service page, it is possible to improve the response speed for a single error.

In addition, according to various embodiments of the present invention, by providing a finite state machine-based tool suitable for operation of a service page, developer convenience and maintenance ease can be improved.

1 is a block diagram illustrating a service system according to an embodiment of the present invention.
2A is a block diagram showing the configuration of a finite state machine operation server according to an embodiment of the present invention.
Fig. 2b is a diagram showing data types allocated to a finite state machine.
3A is an exemplary diagram illustrating a finite state machine diagram schematically illustrating a finite state machine according to an embodiment of the present invention.
3B is a flowchart illustrating a method for generating a finite state machine according to an embodiment of the present invention.
4 is a timing diagram illustrating an operation of a service system according to an embodiment of the present invention.
5 is a flowchart illustrating a service operation method of a finite state machine operation server according to an embodiment of the present invention.
6 is a finite state machine diagram of an emoticon payment application event according to an embodiment of the present invention.
7 is an exemplary diagram illustrating a finite state machine diagram according to an embodiment of the present invention.
8 is a flowchart illustrating a finite state machine verification method according to an embodiment of the present invention.
9A to 9B are diagrams illustrating a finite state machine diagram illustrating an action synthesis process according to an embodiment of the present invention.

The following is merely illustrative of the principles of the invention. Therefore, those skilled in the art will be able to devise various devices which, although not explicitly described or shown herein, embody the principles of the present invention and are included within the spirit and scope of the present invention. In addition, it should be understood that all conditional terms and examples listed herein are, in principle, expressly intended only for the purpose of understanding the inventive concept and are not limited to the specifically enumerated embodiments and states as such. do.

Moreover, it is to be understood that all detailed description reciting specific embodiments, as well as principles, aspects, and embodiments of the present invention, are intended to cover structural and functional equivalents thereof. It is also to be understood that such equivalents include both currently known equivalents as well as equivalents developed in the future, ie, all devices invented to perform the same function, regardless of structure.

Accordingly, it should be understood that all flowcharts, state transition diagrams, pseudo code, etc. may be tangibly embodied on a computer-readable medium and represent various processes performed by a computer or processor, whether or not a computer or processor is explicitly shown. .

The functions of the various elements shown in the figures including a processor or functional blocks represented by similar concepts may be provided by the use of dedicated hardware as well as hardware having the ability to execute software in association with appropriate software. When provided by a processor, the functionality may be provided by a single dedicated processor, a single shared processor, or a plurality of separate processors, some of which may be shared.

The above-described objects, features and advantages will become more apparent through the following detailed description in relation to the accompanying drawings, and accordingly, those of ordinary skill in the art to which the present invention pertains can easily implement the technical idea of the present invention. There will be. In addition, in the description of the present invention, if it is determined that a detailed description of a known technology related to the present invention may unnecessarily obscure the gist of the present invention, the detailed description thereof will be omitted.

Hereinafter, various embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 is a block diagram illustrating a service system according to an embodiment of the present invention. Referring to FIG. 1 , a service system 1000 may include a plurality of terminal devices 100-1, ..100-N: 100 used by a user, and a finite state machine operation server 200 .

The terminal device 100 is a terminal device provided by users, and includes a smart phone, a tablet computer, a notebook computer, a personal computer (PC), a personal digital assistant (PDA), a portable multimedia player (PMP), and a wearable having a wired/wireless communication function. It may be implemented as a wearable device, or may be implemented as a wearable device such as smart glasses or a smart watch that can be worn on a user's body.

Here, the user of the terminal device 100 includes an administrator who has the authority to perform management tasks such as creation, change, manipulation, update, error handling, and the like, of a finite state machine for the operation of the application event page. For example, when development of the application event page is required, collaboration of various departments such as planning, marketing, and CRM (Customer Relationship Management) is required, so members of the planning team, marketing team, CRM team, etc. can manage the finite state machine. It is necessary to be given the authority for, and it is desirable that the authority is not granted to other general users. In the present invention, a user who accesses the finite state machine operation server 200 and manages the finite state machine will be referred to as an "administrator".

In addition, the user of the terminal device 100 may include a general user who accesses the application event page using the Internet function of the terminal device 100 and participates in various application events. For example, a user may access an application event page containing promotional content for customers of a specific company through a search engine, advertisement, etc. using the terminal device 100 , and the user may access the application event displayed on the terminal device 100 . By checking the page, you can participate in the application event provided on the application event page. In the present invention, an external user who accesses the finite state machine operation server 200 and participates in the application event provided on the application event page will be referred to as a “customer”. As an embodiment, when the customer enters the finite state machine, the finite state machine may identify the user information by mapping the personal identifier and the current state information, and transmit screen information corresponding to the customer's current state as a response to the customer terminal device. have.

Meanwhile, terms used in the present invention may be defined as follows.

Specifically, in the present invention, a finite state machine means a computational model composed of a finite number of states and transitions (changes) between these states. A finite state machine consists of multiple users, states, and transitions. Such a finite state machine can cause transitions between states by event occurrence. In addition, the finite state machine can visualize and display the finite state machine using a predetermined schematic tool, and a diagram showing the connection relationship of a plurality of state blocks is called a "finite state machine diagram".

In the present invention, a state may refer to a plurality of states constituting a finite state machine, and each state constituting the finite state machine is like a node of a system waiting to initiate a transition. A user entering the finite state machine according to the present invention is mapped with only one state, and has "current state name" information indicating the mapped state name. The current state of the user may be continuously changed according to the transition.

Further, in the present invention, the state information includes state name information, action information assigned to a state, and may further include related information such as event information assigned to a state.

And, in the present invention, an action means executing an operation to be performed in a corresponding state with respect to each of a plurality of states constituting a finite state machine.

And, in the present invention, the action information is information indicating an action (execution data) to be executed in a corresponding state, and is designated one by one for each state. Here, the action information may include execution information of an API (Application Programming Interface) related to an action to be executed in the corresponding state.

And, in the present invention, an event is an event that transitions (changes) between a plurality of states constituting a finite state machine, and is generated as a result of execution of an external system or action. The event may include a “user event” that occurs through customer input through the application event page and a “machine event” that occurs automatically inside the machine. As an embodiment, the user event may be divided into a customer event (external user event) generated by actions of customers and an event for administrators (internal user event) generated by an event manager's action.

And, in the present invention, the event information may include name information of an event constituting a transition between a plurality of states, event type information such as a user event or a machine event, transition direction information, and the like.

Here, the state information, action information, and event information may be generated based on input data (or coding data) in the manager terminal device 100 that manages the creation and update of a finite state machine. As an embodiment, the manager may access the finite state machine operation server 200 using the manager terminal device 100 and may create a finite state machine through a manager interface provided by the server 200 . As an embodiment, the administrator may input state information, action information, and event information for management of creation and update of a finite state machine through a text-type programming language.

And, in the present invention, a transition refers to a series of operations performed when an event defined between each state occurs. The transition data includes a first state name, an event name, and a second state name, wherein the first state name corresponds to the current state name of the user before the transition, and the second state name is the user after the transition It points to the next state name of Depending on the result of the action, an event can occur and transition can occur continuously. When the transition is stopped because no more events occur, response processing is performed.

Unlike a general finite state machine, the finite state machine according to the present invention can be implemented so that the execution result of an action is the occurrence of an event. For example, if the event E1 constituting the transition from the first state to the second state is implemented only as being generated by the action A1, when the first state is entered, S2 is unconditionally according to the execution of the action A1. An event (E1) that transitions to occurs occurs, and transitions (S2->S3->...) occur in a chain.

When the transition is stopped and the final state of the user is determined, the finite state machine may output a screen according to the final state of the user. For example, if the result of the action consists of an OK event or a FAIL event, only some of the events defined as the output of the action without additional transition (FAIL), or other events (eg, YES or NO) that are not defined in the action When connected to a state, the chain transition stops and the state becomes the final state, as if the user were staying in a specific state.

That is, the finite state machine of the present invention allows an administrator to distinguish a state in which a service page (eg, an application event page) is required. Here, the service page refers to a web page or a mobile application screen displayed on the customer terminal device, and refers to at least one screen related to a corresponding service (eg, an application event). In the present invention, the service page may be referred to as a service page related to an application event, an application event page, a customer interface, or screen information displayed on a customer terminal device, and are used in the same sense. According to the present invention, when designing a finite state machine for an application event, it is possible to prevent a screen from being omitted and to help predict the design period.

For example, the service page related to the application event may be composed of a plurality of pages containing contents such as promotions for customers and contents of the application event that the company wants to promote. For example, in the case of an application event in which an emoticon is paid to a customer, the service page may output a "application page" screen corresponding to the "initial state" when the customer connects for the first time, and the customer's input (click the application button) on the application page ), it is possible to display the "Emoticon payment completion page" screen corresponding to "Emoticon payment completed". In addition, if the emoticon payment fails for the customer's application on the application page, an "emoticon payment failure page" corresponding to the "payment failure status" may be displayed. Such a service page may generate a user event by the user's input by receiving the customer's input, and state transition by the user's event is possible. At this time, the customer's input is a concept that includes all actions of the customer to participate in the application event suggested on the application event page. For example, an act of visiting the application page or clicking the application button on the application page , inputting personal information in the personal information field of the application event page may include all actions of the customer.

2A is a block diagram showing the configuration of a finite state machine operation server 200 according to an embodiment of the present invention. The finite state machine operation server 200 includes a generation unit 210 , an operation unit 220 , and a verification unit 230 for generation and management of the finite state machine, and for general operation of the server and interworking with an external terminal. It may include a control unit 250 , a storage unit 240 , a communication unit 260 , and a manager interface 270 . However, the configuration of the finite state machine operation server 200 is not limited thereto, and a configuration (eg, an input/output unit) necessary for various embodiments of the present invention may be further included or omitted, and two or more configurations are integrated. It can be implemented in the form As an embodiment, the control unit 250 may be a central processing unit (CPU) for driving the server, the storage units 240 and 227 may be implemented in the form of a storage device or a separate database, and other components are It may be implemented in the form of a computer program driven by a processor and recorded on a recording medium of a server.

First, the generator 210 may generate a finite state machine based on an input of a designer or a manager. Specifically, the generator 210 may generate a finite state machine based on state information, action information, and event information for each of a plurality of states received from the initial designer or manager. The generation unit 210 includes an allocation unit 211 , a diagram generation unit 212 , and a synthesis unit 213 .

The allocator 211 may allocate state information and action information indicating an action to be executed in the corresponding state to each of a plurality of states constituting the finite state machine based on data input from the manager. In this case, the allocator 211 may be configured such that the execution result of the action assigned to the state is linked with the occurrence of an event for transition from the corresponding state to the other state, rather than the return of a value.

Also, the allocator 211 may allocate event information for transition from the first state to the second state for each of a plurality of states constituting the finite state machine based on data input from the manager. Here, the event information includes an event name. Hereinafter, for convenience of description, the first state name indicating the state before the transition occurs and the second state name indicating the state after the transition according to the event name are referred to as the first state name, and the transition information includes the first state name and the second state name. 2 It can be defined in a form including a state name and an event name. In the present specification, for convenience of description, the state before the transition is referred to as a first state, and the state after the transition due to an event is referred to as a second state.

As an embodiment, the allocator 211 may generate data defining a plurality of state information and transition information when generating a finite state machine, and the data type may be defined as shown in FIG. 2B . As shown in FIG. 2B , the requested data may include the customer's personal identifier as the requested personal identifier information, and may include the requested event name. The finite state machine fetches the current state name according to the request personal identifier (eg, the initial state name upon initial entry), and assigns the requested event name to a processing schedule event variable called "new event name". Next, in the transition data, the current state name and the new event name match the first event name and the event name, respectively, a transition is found, and when there is a corresponding transition, a transition is made and the second state name is assigned to the user's current state name. . At this time, by assigning a null value to the new event name variable value again, when there are no more events returned by the action, the null value is maintained so that the final state can be known.

The finite state machine executes the entry action mapped to the second event for the user who enters the second state, and when the event name is returned as a result of the execution of the entry action, the returned event name is assigned to the new event name. In this way, if an actual event value, not a null value, is assigned to the variable named new event name, it goes back to the transition check step, finds transition data that matches the user's current state name and new event name, and determines whether or not a transition occurs. can For example, when the transition is stopped because there is no matching transition data, the current state name assigned to the user at that time is viewed as the final state, and screen information mapped to the corresponding state name is output as a response.

As such, the finite state machine of the present invention can be implemented so that the execution result of an action leads to the occurrence of an event, unlike a general finite state machine. The state corresponding to the current state name is determined, the entry action assigned to the corresponding state is executed, and when an event name is returned as a result of the execution of the entry action, a transition is caused by assigning the event name to a new event name variable. Through this mechanism, a chain transition can occur, and when the final state is determined by stopping the transition, screen information mapped to the corresponding state can be transmitted as a response, making it easy to implement services such as application events.

On the other hand, an action is to execute execution information of the API for an operation to be performed in a corresponding state, and one action may be designated for each state. At this time, the finite state machine receives a reference value (ARGUMENT) from the storage unit 227 to execute the action, fills the corresponding values in the action algorithm when performing the action, and the action performs the action according to the reference value. That is, the action is called together with an argument (ARGUMENT) of the API, and after the action is completed, the change (CHANGE) of the storage unit 227 is requested and reflected. As such, the action is implemented so as not to directly access or internally relate to the storage unit 227, and has a state-less characteristic by inquiring and modifying the value of the storage unit 227 only through a finite state machine. .

Here, state-less refers to a characteristic in which output is determined only by input parameters, and the function returns the values required for the next operation without storing it. According to an embodiment of the present invention, if the action is implemented to operate only with the argument values called through the finite state machine without storing the argument values, the effect similar to that of operating in the allocated memory space even when the same program is executed multiple times , and it is easy to perform a remote action, and there is an advantage in that it is easy to identify the value of the storage unit that is referenced or changed before and after the action.

As such, the allocator 211 may allocate state information and action information to each of a plurality of states constituting the finite state machine, and store data to which the state information and the action information are mapped as shown in Table 1.

status information S ₀ S ₁ action information A ₀ A ₁

Additionally, the event may constitute a transition from the first state to the second state. As an example, in the case of an emoticon payment application event, the finite state machine may transition the customer's current state from a "visit state" to a next state, "emoticon payment state", according to the occurrence of an "application event". In this way, the allocator 211 may allocate event information constituting a transition between a plurality of states constituting the finite state machine, and store data to which the state information and the event information are mapped as shown in Table 2.

status information S ₀ -> S ₁ S ₁ -> S ₂ event information E ₀ E ₁

Event types include “user events” that are generated according to user input through the service page and “machine events” that are automatically generated by the machine according to the execution of actions assigned to states. As described above, users include administrators as well as customers. These user events and machine events can be expressed as an event API.

If generation of an event as a result of execution of an action assigned to a state is not requested, the finite state machine controls to display a service page matching the corresponding state on the terminal device 100 of the customer. Thereafter, when a customer input is received through the service page displayed on the customer terminal device 100 , the user-generated event API of the finite state machine may generate a user event corresponding to the customer input.

In this way, by separating the user-generated event API and the machine-generated event API to generate an event, the problem of abuse can be solved. For example, if "NAME_INPUT (name input) event" and "GIVE_MONEY (money payment) event" are described as examples, if "GIVE_MONEY (money payment) event" can be generated according to customer input through the application event page, this Misuse can cause problems.

In order to solve this problem, the finite state machine according to the present invention can distinguish both events through the separation of the user-generated event API and the machine-generated event API. The finite state machine makes it possible to call only events with an uppercase letter in the user-generated event API accessed by the user, so the customer can restrict the authority to only generate specific events. For example, it is possible to provide API execution information filtered to recognize and process only user events while ignoring (or excluding) events other than capital letters for general users with potential for abuse. On the other hand, finite state machine internal services can accept any event name, making it possible to call the machine-generated event API.

The diagram generator 212 schematizes a finite state machine composed of a text-type programming language, and may operate in conjunction with the manager interface 270 or use a specialized tool. The diagram generating unit 212 of the finite state machine may generate a state block corresponding to each of the plurality of states by using the state information and the action information allocated by the allocator 211 , and display the allocated action. In addition, the diagram generator 212 may determine transition data between a plurality of state blocks generated by using the event information, and form a connection relationship between the plurality of state blocks. Accordingly, the diagram generating unit 212 may generate a graph in which each of the plurality of state blocks is connected, but the arrow direction of the connecting line is displayed according to the transition data.

As an embodiment, the manager provides a user interface (UI) (eg, the manager interface 270 ) for creating a finite state machine using the manager terminal device 100 , and the manager uses his/her terminal device ( State information, action information, and event information for each of a plurality of states constituting the finite state machine may be input through the manager interface 270 displayed in 100 ).

The diagram generator 212 schematically provides a finite state machine through the manager interface 270 , so that the manager can easily create and modify it. In other words, an administrator can easily create and manage a finite state machine for the operation of a service page by creating and modifying diagrams. It takes less time and effort than writing a programming language with thousands or tens of thousands of lines of text when designing a finite state machine, and it has the advantage of enabling efficient development and management by intuitively viewing the schematic finite state machine. There is this.

Furthermore, since an administrator who is not a professional developer can understand the diagram, there is an advantage that management by an operator other than the initial developer (eg, advertising, marketing department) is possible. Such a finite state machine diagram will be described in more detail with reference to FIGS. 3 and 7 .

Meanwhile, according to the above description, it has been described that an application (or program) is installed as the manager interface 270 for managing the finite state machine in the finite state machine operation server 200 as an example, but the present invention is not limited thereto. It may be implemented as the corresponding application is installed in 100 . As such, when the manager uses the manager interface installed in the manager terminal device 100 or accesses the server 200 and uses the manager interface 270 , it can be implemented to access through a secure network or through authentication.

The synthesizing unit 213 may generate a finite state machine by synthesizing states including actions whose order does not affect each other among a plurality of states. Specifically, the action synthesizing unit 213 detects consecutive states composed of actions whose order does not affect each other among a plurality of states, and combines the possible number of events generated by each action of the detected states. You can synthesize actions by mapping them to new events. This will be described later with reference to FIG. 7 .

Next, the operation unit 220 is a configuration for operating and managing the finite state machine according to an embodiment of the present invention, and the request receiving unit 221 for receiving a request from a user, and executing the finite state machine for the entered user and an interface providing unit 225 for transmitting a response to the user terminal device based on the user's state determined according to the operation of the executing unit 223 and the operation of the executing unit 223 , and further comprising a storage unit 227 . can do. Although the components 221 to 227 have been described as being separate for each function, the present invention is not limited thereto, and may be operated by one processor or program, and may be implemented in an integrated form in which one or more components are integrated. have.

In one embodiment, the operation unit 220 provides a specific service (eg, an application event) according to the operation of a finite state machine designed in advance by the execution unit 223 , determines a state in response to a user's request, and determines the state The screen information mapped to is transmitted as a response. The storage unit 227 may store the data defined as shown in FIG. 2B so that the user's state, transition, etc. can be determined in connection with the execution unit 223 when the finite state machine is executed.

The request receiving unit 221 may receive request data from the user terminal device 100 , and transmit it to the execution unit 223 to start execution of the finite state machine. As an embodiment, the request receiving unit 221 executes the request data in some cases, such as when the request data does not include a defined configuration or when a service non-execution button (eg, a close button of a pop-up window) is clicked. It can be implemented so that it is not passed to

When the execution unit 223 receives the request data from the request receiving unit 221 , the execution of the finite state machine for the user can be started by using the request personal identifier and the requested event name included in the request data as initial input values. have. The pre-designed finite state machine may be stored in the storage unit 227, and may be executed by interworking of the execution unit 223, the storage unit 227, and the interface providing unit 225 by calling the execution unit 223. have. However, the present invention is not limited thereto, and other components necessary for the execution unit 223 to operate the finite state machine may be linked, and related data may be stored in the storage unit 240 as well as the storage unit 227 . have.

The finite state machine includes state information assigned to each of a plurality of states, action information assigned to each of the plurality of states, and event information constituting a transition between the plurality of states, and state information assigned to a personal identifier of the requested data. Actions, transitions, and the like may be performed according to the .

As described with reference to FIG. 2B, the execution unit 223 of the finite state machine receives the requested data, retrieves the current state name according to the request personal identifier (eg, the initial state name at the time of initial entry), and the requested event name is " It is assigned to the event variable to be processed called "New event name". Next, in the transition data, a transition with the current state name and the new event name matching the first event name is found, and when there is a corresponding transition, a transition is made and the second state name is assigned to the user's current state name. At this time, by assigning a null value to the new event name variable value again, when there are no more events returned by the action, the null value is maintained so that the final state can be known.

The execution unit 223 executes the entry action mapped to the second event for the user who has entered the second state, and when an event name is returned as a result of the execution of the entry action, the returned event name is assigned to a new event name. In this way, if an actual event value, not a null value, is assigned to the variable named new event name, it goes back to the transition check step, finds transition data that matches the user's current state name and new event name, and determines whether or not a transition occurs. can For example, when the transition is stopped because there is no matching transition data, the current state name assigned to the user at that point in time may be viewed as the final state, and screen information mapped to the corresponding state name may be output as a response.

On the other hand, the execution unit 223 according to an embodiment of the present invention restores the context by calling the current state (PC (Program Counter)) and storage (Memory) allocated to the customer when an event occurs by the customer, and , it is possible to proceed with the operation of the program according to the event. Specifically, the customer stays in one state in a finite state machine, and the state alone cannot produce meaningful results, and it is necessary to input, store, restore, and output arbitrary values.

Here, the state of one customer and the memory space for that customer are collectively called a “context”, and in a finite state machine, one customer can have one context. A memory space for each of a plurality of customers accessing the finite state machine operation server 200 may be allocated to the storage unit 227 , and the memory space for each customer includes a customer-specific program code, a memory configuration, and a program counter (execution location). can be stored. In this case, when a customer event occurs, the finite state machine can restore the context by reading the current state (program counter) allocated to the customer and data stored in the memory space.

According to the designed finite state machine, it goes through a series of transition processes such as state transition and action execution, and when responding to an event, the context can be saved by recording the current state and storage again.

That is, a memory space for each of a plurality of connected customers may be allocated to the storage unit 227 according to the present invention, and a program code, a memory configuration and a program counter for each customer may be stored in the memory space for each customer. In this case, the execution unit 223 extracts the data stored in the memory space allocated to the customer when a user event occurs, restores the context, executes the program, and records the current state again when giving a response to the event. Context can be saved. Accordingly, the program can be stopped and restarted for each customer through the process of restoring and recording the context.

Also with respect to events, the finite state machine of the executor 223 may include event logic for automatically generating and generating user events and machine events. The event logic may include a user-generated event API that generates a user event corresponding to a customer input through a service page, and a machine-generated event API that generates a machine event that occurs internally in a finite state machine. The execution unit 223 generates a user event based on a customer input through the service page or generates a machine event in connection with the execution of an action assigned to a state, thereby generating a service page (ie, screen) suitable for the final state of the customer. information) to the customer's terminal device 100 .

As an embodiment, when the request data is received from the customer's terminal device 100 , the execution unit 223 may detect the customer's entry to the service page through the request data and determine whether a user event has occurred. For example, a user-generated event API of a finite state machine may generate a user event upon entry of a customer's entry event page.

When a user event occurs, the execution unit 223 may transition the customer's state from the current state of the customer to the next state through the corresponding user event. Specifically, when a customer input (eg, an input action of clicking an application button displayed on the page) is received through the service page displayed on the customer's terminal device 100, the finite state machine executes the user-generated event API to A user event corresponding to the input may be generated. The finite state machine checks the transition data as the user event occurs in the customer's current state (first state), and then sets the customer's state to the next state (second state) when there is transition data that matches the first state name and the event name. transfer to

Then, the execution unit 223 may detect action information assigned to the state of the customer according to the transition, and execute the action assigned to the state of the customer based on the detected action information. At this time, the execution unit 223 detects an API factor for executing the action assigned to the customer's state from the storage 227, and executes the API corresponding to the customer's state based on the detected factor, After execution, the parameters can be changed.

On the other hand, in the case of a machine event, the machine-generated event API may generate a machine event related to the execution of an action. The occurrence of machine events can cause a customer's state transitions to be performed repeatedly in a finite state machine. For example, if the finite state machine consists of a plurality of states from the first state to the Nth state, and a machine event continuously occurs as a result of execution of an action assigned to the plurality of states, the finite state machine can automatically transition to one of the states of

In another embodiment, when no more machine events occur, the execution unit 223 determines the final status of the user's customer at that point. That is, as the transition is stopped, the "current state name" assigned to the user data at that time becomes the final state. The execution unit 223 transmits the final state of the customer to the interface providing unit 225 , and the interface providing unit 225 controls the terminal device 100 of the customer to display an interface screen corresponding to the final state of the customer. can That is, the screen information stored in the interface providing unit 225 may be transmitted to the customer's terminal device 100 as response data.

According to this embodiment, the generating unit 210 or the operating unit 220 may distinguish whether the output of the service page is required in the customer's terminal device 100 for each state constituting the finite state machine. For example, when the occurrence of a user event is required for a state transition from the first state to the second state (that is, if the finite state machine stays in a specific state without a transition according to the occurrence of a machine event), the finite state machine is The state can be determined as a state that requires expression of the application event page. On the other hand, when the occurrence of a user event is unnecessary for state transition from a specific state to a later state, that is, when a state transition is possible from a specific state to a later state only by the occurrence of a machine event (eg, emoticon payment), the finite state machine is can determine that the display of the service page is unnecessary.

As described above, the interface providing unit 225 stores a service page containing contents such as customer promotions and online events that the company wants to promote, and provides a service page corresponding to the state determined by the execution unit 223 . do. The interface providing unit 225 may store a one-to-one mapping of service pages for a plurality of states constituting each finite state machine. The interface providing unit 225 may receive status information from the execution unit 223 and display a screen corresponding to the corresponding status.

At this time, the method of displaying the screen (web page) to the customer is a method of calling one of several screens pre-stored in the screen storage unit 410 of the finite state machine operation server 200 (call method), or an individual state It can be selectively implemented among the methods (individual matching method) of displaying the screen stored in each.

If it is determined that there is an error according to the verification result, the verification unit 230 may generate and provide detailed error information indicating what the corresponding error is and solution information indicating a solution for solving the corresponding error. Accordingly, the manager checks the region where an error occurs in the finite state machine generated through the terminal device 100 , detailed error information indicating what the corresponding error is, and a solution indicating a solution for solving the corresponding error, and corrects the error. can be easily solved. A detailed operation of the verification unit 230 will be described in more detail with reference to FIG. 8 .

Meanwhile, the controller 250 controls the overall operation of the finite state machine operation server 200 . Specifically, the control unit 250 controls the generation and operation of the finite state machine, the generation unit 210, the operation unit 220, the verification unit 230, the storage unit 240, the control unit 250, the communication unit ( 260), all or some functions of the manager interface 270 may be controlled.

The storage unit 240 is a storage device for recording data necessary for the operation of the finite state machine operation server 200 , and may store the finite state machine data generated by the generation unit 210 , and various functions of other components. It can store data for implementation. In addition, in this figure, the storage unit 240 of the server and the storage unit 227 of the operation unit 230 are separately illustrated, but the present invention is not limited thereto, and may be implemented by one integrated storage device or a plurality of storage devices (eg, , multiple types of memory).

The communication unit 260 may set a communication configuration to enable communication between the terminal device 100 and the finite state machine operation server 200 . Accordingly, the communication unit 260 may transmit data or receive data to the connected customer terminal device 100 . For example, the communication unit 260 may receive a customer input for the application event page, transmit it to the request receiving unit 221 , and transmit response data from the interface providing unit 225 to the customer terminal device 100 .

3A is an exemplary diagram illustrating a finite state machine diagram schematically illustrating a finite state machine according to an embodiment of the present invention. Referring to FIG. 3A , for example, the administrator _{inputs a "S 0} " state to _{which "A 0} " is assigned as an _{action and an "S 1} " state to _{which "A 1} " is assigned as an action through the administrator page. _{and "S 2} " to which "A ₂ " is assigned as an action can be entered. _{Then, the administrator inputs the event "E 0 " constituting the transition from the state "S 0} " to the state "S ₁ " through the administrator page, and configures the transition from the state "S ₁ " to the state "S ₂ ". Event "E ₁ " can be entered. As an embodiment, the administrator may generate a finite state machine by inputting a programming language in the form of a text, and may implement such that the inputted finite state machine is schematized through a modeling tool (eg, plantUML). As described above, the present invention has the advantage of being able to easily grasp each state, action, and event information by diagramming the finite state machine as a diagram, and easy maintenance.

In this case, as an embodiment, the finite state machine diagram generating unit 212, as shown in FIG. 3A , an "S ₀ " state block, an "S ₁ " state block, and an "S ₂ " state block schematically illustrating each state. can create

Then, finite state machine diagram generator 212, connected between as shown in Figure 3a, "S _0" in "S _1" to head arrow line to "S _0" state block to "S _1" state block, is an arrow line towards the "S _2" in "S _1" to create a finite state machine diagram, connected between the "S _1" state block and "S _2" block state.

3B is a flowchart illustrating a method for generating a finite state machine according to an embodiment of the present invention. Referring to FIG. 3B , first, to each of a plurality of states constituting the finite state machine, state information and action information indicating an action to be executed in the corresponding state may be allocated ( S101 ). As an embodiment, in principle, action information is allocated one by one to one piece of state information, but two or more action information may be allocated when a combination of actions is required.

Then, event information for transition from the corresponding state to the subsequent state may be allocated to each of the plurality of states (S102).

Then, a finite state machine may be generated using the allocated state information, action information, and event information (S103).

Here, the generated finite state machine may be configured such that an execution result of an action assigned to a state is an event for transition to another state.

In addition, the step of generating the finite state machine ( S103 ) is a step of automatically setting the corresponding state to the end state when only event information for transition from the previous state to the corresponding state is assigned to the state and the state corresponding to the state When only event information for transition from to a subsequent state is allocated, the method may include automatically setting the corresponding state to the starting state.

In addition, the generating of the finite state machine ( S103 ) may further include a synthesizing step of generating the finite state machine by synthesizing states composed of actions whose order does not affect each other among the plurality of states.

Meanwhile, the method for generating a finite state machine may further include matching and storing a page to be displayed on the customer terminal device 100 in a state in which display of the application event page is essential among the plurality of states.

In addition, the method for generating a finite state machine according to an embodiment of the present invention may further include generating a finite state machine diagram schematically illustrating a finite state machine by using state information and action information allocated to the generated finite state machine. can Specifically, generating a finite state machine diagram includes generating a state block corresponding to each of a plurality of states, determining transition data between a plurality of state blocks generated using event information, and a connection relationship between the plurality of state blocks. It may include the step of forming

The method for generating a finite state machine according to an embodiment of the present invention may further include verifying the generated finite state machine. Here, the verifying step is to determine whether the action assigned to the state is a previously registered action, whether it has passed the argument check of the API for executing the action assigned to the state, and the event generated as a result of the execution of the action assigned to the state to the subsequent state You can verify at least one of whether you have connected to , and whether the required items specified in the state are defined in the storage.

4 is a timing diagram illustrating an operation of a service system according to an embodiment of the present invention. Referring to FIG. 4 , a finite state machine, for example, consists of a first state, a second state, and a third state, and the transition from the first state to the second state consists of a “VISIT” event, and the second state The transition from state to state 3 may consist of a "JOIN" event. Such a finite state machine may be generated in advance and related data may be stored in the storage unit 240 or the storage unit 227 .

As an embodiment, the interface providing unit 225 includes a screen storage unit 410 for storing a service page mapped with a status and a screen display unit 420 for outputting a service page (screen information) to the customer terminal device 100 . include Referring to FIG. 4 , the screen storage unit 410 of the interface providing unit 225 may store service pages for an application event to be displayed on the customer's terminal device 100 . For example, the application event page is a customer interface (or service page), and includes "NONE screen", "VISITED screen", "JOINED screen", "FAILED screen", and "DONE screen". Such a plurality of customer interface screens are generated in advance and stored in the screen storage unit 410, and are stored in a one-to-one mapping with each state.

When the customer enters the application event page for the first time, the screen display unit 420 may detect the application event start screen, which is the initial screen, from the screen storage unit 410 and display it on the first entered customer terminal device 100 ( S201 ). ). In this case, the screen display unit 420 may generate "VISIT EVENT" notifying that the customer has entered the application event start screen and transmit it to the finite state machine (S202).

When it is determined that the customer has entered the application event, such as by receiving "VISIT EVENT", the finite state machine may check the customer's status and generate a response (S203). Specifically, in step S203, the user-generated event API of the finite state machine generates a user event "VISIT EVENT" according to a customer input (page first entry). In addition, the execution unit 223 may make a transition from the first state through the "VISIT EVENT" to transition the customer's state to the second state (VISITED STATE), which is a subsequent state.

The execution unit 223 changes the customer's state to the second state (VISITED STATE) according to the state transition, and when the final state is determined to be the VISITED state without an additional transition event, a screen to be displayed in the corresponding state (VISITED STATE) is interfaced Request to study (225) (S204).

The screen display unit 420 requests a "VISITED screen" from the screen storage unit 410 (S205), and the screen storage unit 410 detects a "VISITED screen" from among a plurality of pre-stored screens and displays the screen display unit 420. can be transmitted to (S206). Accordingly, the screen display unit 420 may display the “VISITED screen” on the customer terminal device 100 ( S207 ). That is, the interface providing unit 225 provides a screen to be displayed according to the request of the finite state machine, so that the screen according to the user's state is displayed.

On the other hand, when the customer clicks the application button on the "VISITED screen" (S208), the screen display unit 420 notifies the execution unit 223 that the customer clicks the application button (user event) has occurred (S209) .

The finite state machine may check the customer's status and generate a response when the "JOIN event occurrence" message is received (S210). Specifically, in step S210, the user-generated event API of the execution unit 223 generates a user event "JOIN event" according to the customer input (customer clicks the application button), and the execution unit 223 is in the second state. Through the "JOIN event" constituting the transition, it is possible to transition the customer's state to the third state, which is the subsequent state.

The execution unit 223 changes the customer's state to the third state (JOINED state) according to the state transition, and when the final state is determined to be the JOINED state without an additional transition event, the screen to be displayed in the corresponding state (JOINED state) is interfaced Request to study (225) (S211).

In this case, the screen display unit 420 requests a "JOINED screen" from the screen storage unit 410 (S212), and the screen storage unit 410 detects a "JOINED screen" among a plurality of pre-stored screens, and the screen display unit It can be transmitted to (420) (S213). Accordingly, the screen display unit 420 may display the "JOINED screen" on the customer terminal device 100 (S214).

As such, the execution unit 223 may classify a state requiring screen display among a plurality of states included in the finite state machine, and may request the interface providing unit 225 to display the screen. In this embodiment, the description has been focused on a method of pre-stored related screen data in the screen storage unit 410 and outputting a screen to be displayed in response to a request from the execution unit 223 . However, the present invention is not limited thereto, and each screen may be stored or displayed by matching an individual state of the finite state machine. In addition, loading of the screen stored in the screen storage unit 410 in FIG. 4 may be performed using a Uniform Resource Locator (URL).

As described above, according to the present invention, the finite state machine generates a user event based on a customer input through the application event page or generates a machine event in connection with the execution of an action assigned to a state, thereby changing the current state of the customer. A suitable application event page may be controlled to be displayed on the customer's terminal device 100 .

5 is a flowchart illustrating a service operation method of the finite state machine operation server 200 according to an embodiment of the present invention. Referring to FIG. 5 , first, a customer may enter a service page using his/her terminal device 100 ( S301 ). For example, the customer may enter the application event page by inputting a URL corresponding to the application event page in his/her terminal device 100 .

Then, the finite state machine may determine whether or not a user event occurs when the entry of the customer is detected by the execution unit 223 ( S302 ). For example, when a pop-up window related to event application is opened to a customer or an advertisement banner is exposed, it may be considered that the user has entered the application event page. At this time, when the user event banner or window is clicked to move to the detailed page for the application event, the finite state machine may determine that a user event (visit event) has occurred.

If the user event does not occur (S302: NO), for example, if the pop-up window is not closed or an advertisement banner is not clicked, the execution unit 223 may end the process (S303).

When a user event occurs (S302: YES), the finite state machine may consider that an event constituting a transition from the current state of the customer has occurred, and may transition the state of the customer to the next state (S304). Specifically, when the finite state machine consists of states 1 to N, the execution unit 223 may transition the state of the customer from the current state of the customer to the next state through the generated user event. .

Then, the execution unit 223 may detect the action information assigned to the state of the customer according to the transition, and execute the action assigned to the state of the customer based on the detected action information ( S305 ). Here, the executing step (S305) is a step of detecting a factor of the API for executing the action assigned to the status of the customer from the storage unit, the steps of executing and executing the API corresponding to the status of the customer based on the detected factor After changing the factors, it may include the step of generating an event related to the execution of the action.

Then, the execution unit 223 may determine whether or not there is an occurrence of a machine event associated with the executed action (S306). Specifically, in step S306, when the machine event is mapped to the action executed in step S305, the machine-generated event API of the execution unit 223 generates the corresponding machine event along with the execution of the action.

When a machine event occurs (S306: YES), the execution unit 223 may transition the customer's state from the current state of the customer to a subsequent state through the generated machine event (S304).

These steps S304, S305 and S306 can be repeatedly performed under the condition that a machine event occurs in the machine-generated event API for all of the first to N-th states constituting the finite state machine. In case S306, successive transitions may occur.

However, if the machine event does not occur (S306: NO), the execution unit 223 determines the final state of the customer (S307), transmits the final state of the customer to the interface providing unit 225, and the interface providing unit 225 ) may display an interface screen corresponding to the final state of the customer on the customer's terminal device 100 ( S308 ).

6 is a finite state machine diagram of an emoticon payment application event according to an embodiment of the present invention. Referring to FIG. 6 , the finite state machine has a starting state (30), a visited state (31), an emoticon payment state (32), a payment failure state (33), and a payment completion state for an application event for emoticon payment. (34) may be included.

When a customer accesses a service page using his/her terminal device 100 in order to participate in an emoticon payment application event, the user-generated event API of the finite state machine may generate a "visit event" (VISIT event). In this case, the state of the customer in the finite state machine can be transitioned from the starting state 30 to the visited state 31 .

And, in the finite state machine, if there is no automatic transition due to a machine event in the visited state 31, the customer sees the visited state 31 as the final state, and the "page for application" matched to the visited state can be detected and provided to customers. In this case, the customer terminal device 100 may display a “page for application”.

After that, when a customer input of clicking the application button of the “page for application” is received in order to participate in the emoticon payment application event, the user-generated event API of the finite state machine generates an “application event” (JOIN event). . According to the occurrence of an event, the state of the customer in the finite state machine may be transitioned from the visited state 31 to the emoticon payment state 32 . Then, the finite state machine may execute the emoticon payment API assigned to the emoticon disbursing state 32 .

If emoticon payment is successful as a result of executing the emoticon payment API, the machine-generated event API of the finite state machine may generate a "payment completion event" (machine event). At this time, the state of the customer in the finite state machine is transferred from the emoticon payment in progress state 32 to the payment completion state 34 . Since the finite state machine does not have additional transitions, the final state the customer has reached is regarded as the payment completion state 34 , and a "page for emoticon payment completion notification" matched to the payment completion state 34 is detected and sent to the customer. You can provide that page. In this case, the customer terminal device 100 may display the matched "page for notification of payment completion of emoticons".

However, if emoticon payment fails as a result of executing the emoticon payment API, the machine-generated event API of the finite state machine may generate a “payment failure event”. In this case, the state of the customer in the finite state machine transitions from the emoticon payment in progress state 32 to the payment failure state 33 . Similarly, the finite state machine sees the final state reached by the customer as the payment failure state (33) if no further transitions occur, and the finite state machine matches the payment failure state (33) to the “page for emoticon payment failure notification”. By detecting ", it is possible to provide the corresponding page screen to the customer in the visited state (33).

As an embodiment, the administrator may design to retry the payment when the payment fails (RESEND function). For example, when a payment failure event occurs, the finite state machine may transition the customer to the payment failure state 33 and output a payment failure page. At the same time (or after several seconds have elapsed), it can be implemented to automatically retry the payment, transition the state to the emoticon payment state 32 and try the payment once more. This is an optional function and may be appropriately implemented according to the design of the administrator.

In another embodiment, the RESESND function may be implemented as a user event by the administrator to be manually retried by the administrator. In another embodiment, a machine event such as REPEAT_10M (eg, retry every 10 minutes) may be implemented to automatically retry every predetermined time.

The state block according to FIG. 6 will be described in terms of the algorithm according to FIG. 5 as follows. The operations of the finite state machine, which will be described later, are operated by the operation unit 220 of the server 200, and for convenience of description, the finite state machine may be expressed as if the finite state machine performs operations such as transitions, events, and actions. This is because the finite state machine is actually implemented by the organic operation of the components 221 , 223 , 225 , and 227 included in the operation unit 220 .

When the customer enters the application event page using his/her terminal device 100 to participate in the emoticon payment application event (S301), the user-generated event API of the finite state machine responds to the customer's input "entering the application event page" A corresponding "visited event" may be generated (S302: YES), and the state of the customer may be transitioned from the starting state 30 to the visited state 31 in the finite state machine (S304).

Then, the finite state machine executes the action assigned to the visited state 31 (S305), and as a result of the action, it is determined whether a machine event is generated in the machine-generated event API of the finite state machine (S306). In this embodiment, since the finite state machine does not generate a machine event associated with the execution of an action assigned to the visited state 31 (S306: NO), the finite state machine visits the final state of the customer ( 31) is determined (S307). The execution unit 223 transmits the current state name of the customer to the interface providing unit 225 as the visited state 31 name, and the interface providing unit 225 corresponds to the visited state 31 which is the final state of the customer. A "page for application" may be displayed on the customer's terminal device 100 (S308).

On the other hand, when the customer in the visited state 31 clicks on the application window on the "page for application" displayed on his or her terminal device 100 (S301), the user-generated event API of the finite state machine is the customer's input "Application" An “apply button click event” corresponding to “window click” may be generated (S302: YES), and the finite state machine may transition from the state 31 of visiting the customer state to the state of paying emoticons 32 (S304). ).

Then, the finite state machine executes the emoticon payment API assigned to the emoticon disbursing state 32 . When the emoticon payment is successful as a result of the execution of the emoticon payment API in the finite state machine, the machine-generated event API of the finite state machine may generate a “payment completion event” that is a machine event related to the execution of the action (S306: YES) .

In this case, the finite state machine transitions the customer's state from the emoticon payment in progress state 32 to the payment completion state 34 (S304), executes the action assigned to the payment completion state 34 (S305), and a finite It may be determined whether a machine-generated event is generated by the machine-generated event API of the state machine (S306). In this embodiment, the finite state machine does not generate a machine-generated event in the machine-generated event API associated with the execution of an action assigned to the paid-in state 34 (S306: NO), so the finite state machine is the customer's current state. (The final state) is determined as the payment completion state 34 (S307). The execution unit 223 transmits the final state of the customer to the interface providing unit 210, and the interface providing unit 225 corresponds to the payment completion state 34, which is the final state of the customer. " can be displayed on the customer's terminal device 100 (S308).

On the other hand, when the emoticon payment fails as a result of the execution of the emoticon payment API in the finite state machine, the machine-generated event API of the finite state machine may generate a “payment failure event” that is a machine event related to the execution of the action (S306: YES). In this case, the finite state machine transitions the customer's state from the emoticon payment in progress state 32 to the payment failure state 33 (S304), executes the action assigned to the payment failure state 33 (S305), and a finite It is determined whether a machine event is generated by the machine-generated event API of the state machine (S306). Since the finite state machine does not generate a machine event in the machine-generated event API associated with the execution of the action assigned to the payment failure state 33 (S306: NO), the finite state machine returns the customer's final state to the payment failure state (S306: NO). 33) is determined (S307), and the final state of the customer is transmitted to the interface providing unit 225, and the interface providing unit 225 corresponds to the payment failure state 33, which is the final state of the customer. A page for "can be displayed on the customer's terminal device 100 (S308).

7 is an exemplary diagram illustrating a finite state machine diagram according to an embodiment of the present invention. As an embodiment, the administrator may generate a finite state machine by inputting a programming language in the form of a text, and may implement the inputted finite state machine to be schematized through a modeling tool (eg, plantUML).

Referring to FIG. 7( a ), for example, an administrator designs a finite state machine through the manager interface 270 , but assigns an “A ₀ ” action to the _{“S 0” state through the generator 210 .} , and, and "S _1" state is assigned to the "a _1" action "S _2" state, may generate a finite state machine is assigned a "a _2" action. Then, the manager inputs event "E _{0 " constituting the transition from state "S 0} " to state "S ₁ ", and event "E _{1 constituting the transition from state "S 1} " to state "S _{2 ".} " can be entered.

As described above, the present invention has the advantage of being able to easily grasp each state, action, event information, and transition direction by diagramming the finite state machine as a diagram, and easy maintenance.

In this case, as an embodiment, the diagram generating unit 212 may generate an “S ₀ ” state block, an “S ₁ ” state block, and an “S ₂ ” state block, as shown in FIG. 7A . Actions to be performed in each block may be assigned to the generated state block and displayed together.

And, the diagram generating unit 212, as shown in Fig. 7 (a), "S ₀ " to "S ₁ ", connecting the arrow line from "S ₀ " to the "S ₁ " state block between the "S 1 " state block, is an arrow line towards the "S _2" in "S _1" to create a finite state machine diagram, connected between the "S _1" state block and "S _2" block state.

As another embodiment of the present invention, a connection line indicating a user event and a connection line indicating a machine event may be distinguished and displayed in a finite state machine. This will be described in more detail with reference to FIG. 7(b).

7B is an exemplary diagram illustrating a finite state machine diagram according to an embodiment of the present invention. The administrator enters the user event "E ₀ " _{constituting the transition from state "S 0} " to state "S ₁ ", and the machine event "E _{1 " constituting the transition from state "S 1} " to state "S _{2 ".} " can be entered. In this case, as shown in Fig. 7(b), the diagram generating unit 212 _{displays the connecting line constituting the transition from the "S 0} " state block to the "S ₁ " state block as a dotted line, and the "S ₁ " state block A finite state machine diagram can be generated in which the connecting lines constituting the transition from the “S _{2 ” to the state block are separated by solid lines.} However, this is only an example, and the present invention is not limited to such an expression method, and a connection line corresponding to a user event and a connection line corresponding to a machine event may be distinguished in different colors or shapes.

7C is a diagram illustrating a state block displayed when an error is found as a result of the operation of the finite state machine verification unit 230 according to an embodiment of the present invention. Figure 7 (c) Referring to, if the verification result an error in the "S _1" state of the finite state machine verification unit 230, a finite state machine verification unit 230 is an error has occurred that indicates the "S _1" state The status block may be displayed to be distinguished from a status block indicating an error-free state by color, contrast, or the like. As such, by displaying the status block in which an error has occurred to be distinguished, the administrator can quickly and intuitively check whether an error has occurred.

If it is determined that there is an error according to the verification result, the finite state machine verification unit 230 may generate and provide detailed error information indicating what the corresponding error is and solution information indicating a solution for solving the corresponding error. Accordingly, the manager checks the region where an error occurs in the finite state machine generated through the terminal device 100 , detailed error information indicating what the corresponding error is, and a solution indicating a solution for solving the corresponding error, and corrects the error. can be easily solved.

Meanwhile, the finite state machine diagram may indicate which state among the plurality of states the plurality of customers accessing the application event page corresponds to. Specifically, a memory space may be allocated to the storage unit 227 for each of a plurality of customers accessing the application event page, and a current state of each customer in the finite state machine may be stored in the memory space. Accordingly, according to the present invention, it is possible to determine in which state among a plurality of states constituting a finite state machine, a plurality of customers who have accessed an event page by reading data stored in a memory space for each customer are staying in the finite state machine. You can display this information in a diagram (eg, number the number of customers in a status block).

8 is a flowchart illustrating a finite state machine verification method according to an embodiment of the present invention. Although the figure shows that the determination requirements S402 to S405 for verification of the finite state machine are sequentially determined, the present invention is not limited thereto, and the order of each determination requirement may be changed or verification may be performed in parallel. . In addition, although the verification method in which the first to fourth verification steps are performed has been described in this drawing, an additional verification step may be further included or some verification steps may be omitted.

Referring to FIG. 8 , when the step of verifying the first generated finite state machine is started (S401), it is possible to verify whether the action is a pre-registered action (S402: first verification responsibility). If the action is a pre-registered action (S402: YES), the finite state machine verification unit 240 may determine that the verification for this item has passed and proceed to the next verification step. However, if the action is not a previously registered action (S402: NO), the finite state machine verification unit 230 may determine that there is an error in the corresponding state (S407).

In addition, it is possible to verify whether or not an argument (argument) check of the API for executing the action assigned to the state has been passed (S403: second verification step). If it does not pass the factor check of the API for executing the action assigned to the state (S403: NO), the finite state machine verification unit 240 may determine that there is an error in the corresponding state (S407). However, if the API factor check for executing the action assigned to the state is passed (S403: YES), the finite state machine verification unit 230 determines that the verification for this matter has passed and can proceed with the next verification step. have.

In addition, it is possible to verify whether an event generated as a result of the execution of the action assigned to the state is connected to the subsequent state (S404: third verification step). If the event generated as a result of the execution of the action assigned to the state is connected to the subsequent state (S404: YES), the finite state machine verification unit 230 determines that the verification for this matter has passed and can proceed with the next verification step. have. If the event generated as a result of the execution of the action assigned to the state is not connected to the subsequent state (S404: NO), the finite state machine verification unit 230 may determine that there is an error in the corresponding state (S407).

Also, it may be verified whether an item designated as mandatory among the arguments of the action is stored in the property (S405: fourth verification step). If it is determined that an item designated as mandatory among the action factors is not stored in the property (S405: NO), the finite state machine verification unit 230 may determine that there is an error in the corresponding state (S407). However, if it is determined that an item designated as mandatory among the action factors is stored in the property (S405: YES), the finite state machine verification unit 230 may terminate the verification and determine that an error does not exist in the finite state machine. (S406).

Meanwhile, the method according to an embodiment of the present invention may further include displaying a state block determined to be an error according to verification in the finite state machine to be distinguished from a state block having no error.

In addition, the method according to an embodiment of the present invention may further include displaying, on the finite state machine, which state among the plurality of states the plurality of customers accessing the event page correspond to.

In addition, the method according to an embodiment of the present invention includes executing at least one of a user-generated event API and the machine-generated event API to generate at least one of a user event and a machine event for transition from a corresponding state to another state. may further include.

Also, the method according to an embodiment of the present invention may further include distinguishingly displaying a connection line indicating a user event and a connection line indicating the machine event in a finite state machine.

9A to 9B are diagrams illustrating a finite state machine diagram illustrating an action synthesis process according to an embodiment of the present invention. 9A shows a synthesis method of an action that branches to a plurality of results by designing two or more states to have respective result values, and FIG. 9B shows a method for synthesizing two or more actions in one state and branching to a plurality of results The synthesis method is shown. 9A and 9B are for determining whether two conditions of CHECK1 and CHECK2 are satisfied and branching into three result values (number of cases) of ERROR1, ERROR2, and OK, and FIGS. 9A and 9B are different An example implemented in this way is shown. Combining the actions with reference to FIGS. 9A to 9B may be performed by the synthesizing unit 213 when generating the finite state machine.

Referring to Figure 9a, the finite state machine diagram is a state transitioning from state "INITED(11)" when a "False" event occurs by executing a "CHECK1" action in state "INITED(11)", state "INITED(11)". "ERROR1(12)", state "TEMP(13)", state "TEMP", transitioning from state "INITED(11)" when "True" event occurs by executing "CHECK1" action in state "INITED(11)" Execute the "CHECK2" action in "(13)" and execute the "CHECK2" action in "ERROR2(14)", the state "TEMP(13)", which is a transition from the state "TEMP(13)" when a "False" event occurs Thus, when a "True" event occurs, it may be configured as "OK(15)", which is a state transitioned from the state "TEMP(13)". Here, the finite state machine diagram according to Fig. 9a shows that the order of the "CHECK1" action executed in the state "INITED(11)" and the "CHECK2" action executed in the state "TEMP(13)" may not affect each other. .

In this case, as shown in FIG. 9B , the action synthesizing unit 213 synthesizes “CHECK1” and “CHECK2”, which are actions whose order does not affect each other among a plurality of states, into one state (INITED 21 ) and is finite. You can create a state machine. Specifically, the finite state machine diagram representing the finite state machine synthesized in the action synthesizing unit 213 is obtained by executing the "CHECK1" action and the "CHECK2" action in the state "INITED(21)" and "INITED(21)". When the "False#1" event occurs because none of them pass, the "ERROR1(22)" transitions from the state "INITED(21)", the "CHECK1" action and the "CHECK2" action in the state "INITED(21)" When the "False#2" event occurs, the "ERROR2(23)" transitions from the state "INITED(21)", the "CHECK1" action and the "CHECK2" in the state "INITED(21)" It may consist of a state "OK(24)" which is a transition from state "INITED(21)" upon occurrence of "True" event by executing the action and passing both.

According to the synthesizing unit 213 according to the present invention, the size of the finite state machine diagram can be reduced, so that administrators can read it, and the related states and actions can be grouped and modularized, which can be very helpful for reusability.

As described above, according to various embodiments of the present invention, by providing a finite state machine that can flexibly respond to the operation of a service page such as design, addition, and change of services such as an application event, the convenience of the manager is improved and the design is efficient and operation becomes possible.

In addition, according to various embodiments of the present disclosure, service procedures (action execution, state transition, screen provision, etc.) according to machine events or user events are automated through a finite state machine, and business logic in a complex sequence is dynamically configured. By doing so, it is possible to minimize the load and capacity of the server for the application event.

On the other hand, in the specification and claims, terms such as "first", "second", "third", and "fourth", if any, are used to distinguish between similar elements, although this is not necessarily the case. Used to describe a specific sequence or sequence of occurrences. It will be understood that the terms so used are interchangeable under appropriate circumstances to enable the embodiments of the invention described herein to operate, for example, in sequences other than those shown or described herein. Likewise, where methods are described herein as including a series of steps, the order of those steps presented herein is not necessarily the order in which those steps may be performed, and any described steps may be omitted and/or Any other steps not described may be added to the method.

Also, terms such as "left", "right", "front", "behind", "top", "bottom", "above", "below" in the specification and claims are used for descriptive purposes, It is not necessarily intended to describe an invariant relative position. It will be understood that the terms so used are interchangeable under appropriate circumstances to enable the embodiments of the invention described herein to operate otherwise than, for example, as shown or described herein. As used herein, the term “connected” is defined as being directly or indirectly connected in an electrical or non-electrical manner. Objects described herein as being "adjacent" to one another may be in physical contact with one another, in proximity to one another, or in the same general scope or area as appropriate for the context in which the phrase is used. The presence of the phrase “in one embodiment” herein refers to the same, but not necessarily, embodiment.

In addition, in the specification and claims, references to 'connected', 'connecting', 'fastened', 'fastening', 'coupled', 'coupled', etc. It is used in the sense of being connected or indirectly connected through other components.

In addition, the suffixes "module" and "part" for the components used in this specification are given or mixed in consideration of the ease of writing the specification, and do not have distinct meanings or roles by themselves.

In addition, the terms used herein are for the purpose of describing the embodiments and are not intended to limit the present invention. As used herein, the singular also includes the plural unless specifically stated otherwise in the phrase. As used herein, 'comprise' and/or 'comprising' means that a referenced component, step, operation and/or element is the presence of one or more other components, steps, operations and/or elements. or addition is not excluded.

Meanwhile, the above-described methods according to various embodiments of the present invention may be implemented as a program and provided to a server or devices. Accordingly, each device can download the program by accessing the server or device in which the program is stored.

In addition, the above-described methods according to various embodiments of the present invention may be implemented as a program and stored in various non-transitory computer readable media to be provided. The non-transitory readable medium refers to a medium that stores data semi-permanently, rather than a medium that stores data for a short moment, such as a register, cache, memory, etc., and can be read by a device. Specifically, the above-described various applications or programs may be provided by being stored in a non-transitory readable medium such as a CD, DVD, hard disk, Blu-ray disk, USB, memory card, ROM, and the like.

In addition, although preferred embodiments of the present invention have been illustrated and described above, the present invention is not limited to the specific embodiments described above, and the technical field to which the present invention pertains without departing from the gist of the present invention as claimed in the claims Various modifications are possible by those of ordinary skill in the art, and these modifications should not be individually understood from the technical spirit or prospect of the present invention.

100: terminal device 200: finite state machine operation server
210: generating unit 211: allocating unit
212: diagram generation unit 213: synthesis unit
220: operation unit 221: request receiving unit
223: execution unit 225: interface providing unit
227: storage unit 230: verification unit
240: storage unit 250: control unit
260: communication unit 270: administrator interface

Claims (30)

A method for generating a finite state machine by a finite state machine operating server, the method comprising:
allocating state information and action information to be executed in the corresponding state to each of a plurality of states constituting the finite state machine;
allocating event information for transition from a corresponding state to a subsequent state for each of the plurality of states; and
generating a finite state machine using the allocated state information, action information, and event information;
The generated finite state machine includes event logic that generates a user event corresponding to a customer input through a service page and a machine event that occurs internally in the finite state machine,
The generated finite state machine is
The method for generating a finite state machine, characterized in that the execution result of the action assigned to the corresponding state is configured to be linked with the occurrence of an event for transition to another state, and is implemented to generate a chain transition according to the occurrence of the event. According to claim 1,
generating a state block corresponding to each of the plurality of states by using the allocated state information and action information;
generating a finite state machine diagram in which a connection relationship between the plurality of generated state blocks is formed by using the allocated event information; and
and providing a manager interface including the generated finite state machine diagram to a terminal device of a manager. According to claim 1,
and storing the service page to be displayed on the customer's terminal device by matching the corresponding state to a state in which the service page needs to be displayed among the plurality of states. According to claim 1,
Creating the finite state machine comprises:
automatically setting the state to the end state when only event information for transition from the previous state to the corresponding state is assigned to the state; and
When only event information for transition from a corresponding state to a subsequent state is allocated to the state, automatically setting the corresponding state to the starting state; 3. The method of claim 2,
verifying the generated finite state machine; further comprising;
The verification step is
Whether the action assigned to the state is a pre-registered action, whether the API argument check for executing the action assigned to the state has been passed, whether the event that occurs as a result of the execution of the action assigned to the state is connected to the subsequent state and verifying at least one of whether or not a required item specified in the state is defined in the storage. 6. The method of claim 5,
and displaying the state state block determined to be an error according to the verification on the finite state machine diagram so as to be distinguished from the state block having no error. According to claim 1,
Creating the finite state machine comprises:
detecting consecutive states consisting of actions whose order does not affect each other among the plurality of states; and
and synthesizing an action by mapping an event generated by each action in the detected states to a new event by combining all possible cases. 3. The method of claim 2,
and displaying, on the finite state machine diagram, which states among a plurality of states of a plurality of customers accessing the service page correspond. 3. The method of claim 2,
and distinguishing a connecting line representing the user event and a connecting line representing the machine event and displaying the distinguishing line on the finite state machine diagram. In the finite state machine operation server,
a manager interface that provides an interface for the creation of a finite state machine;
State information and action information to be executed in the corresponding state are allocated to each of a plurality of states constituting the finite state machine based on a manager input through the manager interface, and, for each of the plurality of states, a subsequent state from the corresponding state a generation unit for allocating event information for transition to , and generating a finite state machine using the allocated state information, action information, and event information;
The generated finite state machine includes event logic that generates a user event corresponding to a customer input through a service page and a machine event that occurs internally in the finite state machine,
The generated finite state machine is
A finite state machine operation server, characterized in that the execution result of the action assigned to the corresponding state is configured to be linked with the occurrence of an event for transition to another state, and is implemented to generate a chain transition according to the occurrence of the event. 11. The method of claim 10,
The generating unit,
A finite state machine diagram in which a state block corresponding to each of the plurality of states is generated using the allocated state information and the action information, and a connection relationship between the generated state blocks is formed using the allocated event information a diagram generating unit to generate
and the manager interface provides a manager interface including the generated finite state machine diagram to a terminal device of a manager. 11. The method of claim 10,
and a storage unit for matching and storing the service page to be displayed on the customer's terminal device in a state requiring exposure of the service page among the plurality of states. 11. The method of claim 10,
The generating unit,
When only event information for transition from the previous state to the corresponding state is assigned to the state, the state is automatically set to the end state, and only event information for transition from the corresponding state to the next state is assigned to the state , a finite state machine operation server, characterized in that automatically setting the corresponding state to the starting state. 12. The method of claim 11,
Further comprising; a verification unit that verifies the generated finite state machine;
The verification unit,
Whether the action assigned to the state is a pre-registered action, whether the API argument check for executing the action assigned to the state has been passed, whether the event that occurs as a result of the execution of the action assigned to the state is connected to the subsequent state and verifying at least one of whether or not a required item specified in the state is defined in the storage. 15. The method of claim 14,
The diagram generating unit,
and displaying the state state block determined to be an error according to the verification on the finite state machine diagram to be distinguished from the state block having no error. 11. The method of claim 10,
The generating unit,
Among a plurality of states, consecutive states composed of actions whose order does not affect each other are detected, and the event generated by each action of the detected states is mapped to a new event by combining the number of possible cases to create an action. A finite state machine operation server further comprising a synthesizing unit for synthesizing. 12. The method of claim 11,
The diagram generating unit,
and displaying, on the finite state machine diagram, which states among a plurality of states of a plurality of customers accessing the service page. 12. The method of claim 11,
The diagram generating unit,
and distinguishing a connecting line representing the user event and a connecting line representing the machine event, and displaying the distinguishing line on the finite state machine diagram. A method for operating a finite state machine by a finite state machine operation server, the method comprising:
receiving the request data from the customer terminal device;
generating a user event corresponding to the received request data, and having a transition corresponding to the generated user event from a first state that is a current state of a customer among a plurality of states constituting the finite state machine transitioning the customer's state to a second state;
detecting action information assigned to the second state, and executing an action assigned to the second state based on the detected action information; and
determining whether a machine event related to the executed action has occurred, and determining the final state of the customer according to whether the machine event has occurred;
The finite state machine is
A finite state machine operating method, characterized in that the execution result of the action assigned to the corresponding state is configured to be linked with the occurrence of an event for transition to another state, and is implemented to generate a chain transition according to the occurrence of the event. 20. The method of claim 19,
when a machine event occurs in association with the executed action, transitioning the state of the customer from the second state to a subsequent state, a third state having a transition consistent with the generated machine event; How to operate the machine. 21. The method of claim 20,
determining the final state of the customer as the second state if a machine event does not occur in connection with the executed action;
detecting a service page matching the second state; and
and transmitting the detected service page to the terminal device of the customer. 20. The method of claim 19,
wherein the finite state machine includes a user-generated event API that generates a user event corresponding to a customer input through the service page, and a machine-generated event API that generates a machine event that occurs internally in the finite state machine. How the state machine works. 20. The method of claim 19,
The executing step is
detecting an argument of an API (Application Program Interface) for executing the action assigned to the second state;
executing an API corresponding to the second state based on the detected factor; and
and changing parameters after the execution of the API corresponding to the second state. In the finite state machine operation server,
a request receiving unit for receiving request data from the customer terminal device;
generating a user event corresponding to the received request data, and moving the customer from a first state among a plurality of states constituting the finite state machine to a subsequent state having a transition corresponding to the generated user event to a second state. an execution unit that transitions a state, detects action information assigned to the second state, and executes an action assigned to the second state based on the detected action information;
The execution unit determines whether a machine event related to the executed action occurs, and determines the final state of the customer according to whether the machine event occurs,
The finite state machine is
A finite state machine operation server, characterized in that the execution result of the action assigned to the corresponding state is configured to be linked with the occurrence of an event for transition to another state, and is implemented to generate a chain transition according to the occurrence of the event. 25. The method of claim 24,
The execution unit,
when a machine event occurs in connection with the executed action, transitioning the state of the customer from the second state to a subsequent state, a third state, having a transition consistent with the generated machine event. machine operation server. 26. The method of claim 25,
The execution unit,
If a machine event does not occur in connection with the executed action, determining the final state of the customer as the second state, and detecting a service page matching the second state,
The finite state machine operation server further comprising a; an interface providing unit for transmitting the detected service page to the terminal device of the customer. 25. The method of claim 24,
wherein the finite state machine includes a user-generated event API that generates a user event corresponding to a customer input through the service page, and a machine-generated event API that generates a machine event that occurs internally in the finite state machine. State machine operating server. 25. The method of claim 24,
The execution unit,
Detects an argument of an API (Application Program Interface) for executing the action assigned to the second state, executes the API corresponding to the second state based on the detected argument, and the second state A finite state machine operation server that changes the parameters after the execution of the corresponding API. A program stored in a computer-readable recording medium to execute the method for generating a finite state machine according to any one of claims 1 to 9. A program stored in a computer-readable recording medium to execute the finite state machine operating method according to any one of claims 19 to 23.

Images