CN110249356B

CN110249356B - Sharing method and system for user-defined ERP function

Info

Publication number: CN110249356B
Application number: CN201780077869.8A
Authority: CN
Inventors: 李康秀
Original assignee: Duzon Bizon Co ltd
Current assignee: Duzon Bizon Co ltd
Priority date: 2016-11-25
Filing date: 2017-02-28
Publication date: 2023-10-10
Anticipated expiration: 2037-02-28
Also published as: KR101944973B1; KR20180059602A; CN110249356A; WO2018097407A1

Abstract

The invention provides a method and a system, comprising a user-defined ERP function sharing system, which receives a source packet which comprises at least one SQL file and a design file and corresponds to a preset ERP user-defined function from a plurality of sharer terminals, wherein the design file is a file for storing at least one control attribute information forming a user-defined ERP function picture, and at least one part of controls forming the picture of the user-defined ERP function is a control mapped to a specific query included in the at least one SQL file; the user-defined ERP function sharing system stores source packages received from a plurality of sharer terminals in a predetermined storage library; the user-defined ERP function sharing system provides a source packet list stored in a storage library to a user terminal; and transmitting a target source packet selected by the user terminal from among the source packets stored in the repository to the user terminal in response to the request of the user terminal.

Description

Sharing method and system for user-defined ERP function

Technical Field

The invention relates to a sharing method and a sharing system of user-defined ERP functions. More particularly, the present invention relates to a method and system that enables users, such as enterprises, who use ERP software to share user-defined ERP functions, which are self-developed and adapted to their own business processes, with others.

Background

Enterprise resource planning (Enterprise Resource Planning) is a computer system for enterprise operations and business management, or software packages installed in these systems. Representative companies providing ERP service are SAP and Oracle, and korean representative company is DOUZONE. Meanwhile, in order for the enterprise to accept the ERP service, not only ERP software needs to be installed in the user terminal of the enterprise, but also a database for storing various information of the related enterprise must be established.

Through the ERP system, enterprises can effectively manage accounting, personnel, wages, sales, trade, purchasing, materials, production, outsourcing, service and business information. In addition, by introducing ERP systems, enterprises can maximize productivity by reducing inefficiency between management departments due to different information systems. Additionally, ERP may provide the advantage of systematically identifying and managing various information of an enterprise.

Because each company has its own inherent business processes and has different business operations policies, it is necessary to customize ERP software to accommodate the characteristics, business processes, and workflows of the enterprise, unlike a generic software package. Conventionally, in order to construct a customized ERP system for each enterprise, it is necessary to analyze requirements and business processes of each enterprise and develop customized ERP software based thereon to be suitable for each enterprise, so that it takes a lot of time and money to construct a customized ERP system suitable for each enterprise. In addition, due to the high cost, it is difficult for enterprises of small scale to introduce ERP systems.

Disclosure of Invention

Technical problem

The technical problem to be solved by the present invention is to provide a method and system for providing an integrated development environment to integrally develop database modeling, SQL query and UI for operating the database, enabling customized ERP individual functions suitable for enterprises to be easily generated, and allowing users to easily share ERP functions developed by themselves with others.

Technical solution

According to one aspect of the invention, a method of sharing a user-defined ERP (Enterprise Resource Planning) function (function) includes: a step of receiving, by a user-defined ERP function sharing system, a source package corresponding to a predetermined ERP user-defined function from a plurality of sharer terminals, the source package including at least one SQL file and a design file, wherein the SQL file is a file storing a structured query language (SQL: structured Query Language) query for operating a database, the design file is a file storing at least one control attribute information constituting the user-defined ERP function screen, wherein at least a portion of controls constituting the user-defined ERP function screen are controls mapped to specific queries included in the at least one SQL file; a step in which the user-defined ERP function sharing system stores source packages received from a plurality of sharer terminals in a predetermined repository; providing a source package list stored in the repository to a user terminal by the user-defined ERP function sharing system; and transmitting a target source packet selected by the user terminal from among source packets stored in the repository to the user terminal in response to a request of the user terminal.

According to one embodiment, the step of storing source packages received from the plurality of sharer terminals to a predetermined repository by the user-defined ERP function sharing system may include: a step of determining to which of a predefined plurality of categories a user-defined ERP function corresponding to the source package belongs; and classifying the source package into a category to which the corresponding user-defined ERP function belongs and storing the source package into the repository.

According to one embodiment, the step of determining to which of a predefined plurality of categories the user-defined ERP function corresponding to the source package belongs may comprise: analyzing at least one SQL file contained in the source package or a design file contained in the source package; and judging which one of a plurality of categories the user-defined ERP function corresponding to the source package belongs to based on the analysis result.

According to an embodiment, the user terminal performs a source packet uploading method and a source packet downloading method, and the source packet uploading method may include: a step of providing a source package upload UI providing a function of selecting at least some items from a list of at least one source package stored in the user terminal; and a step of transmitting a source package corresponding to the selected item to the user-defined ERP function sharing system through the source package upload UI, the source package download method comprising: a step of receiving a source package list stored in the repository from the user-defined ERP function sharing system; a step of providing a source package download UI that provides a function of selecting at least some items from the received source package list; and a step of receiving a source package corresponding to the selected item from the user-defined ERP function sharing system through the source package download UI.

According to one embodiment, the user terminal receives the target source package from the user-defined ERP function sharing system, and then executes a method for generating user-defined ERP functions corresponding to the target source package, and the method for generating user-defined ERP functions corresponding to the target source package may include: a step of providing a container UI including UI objects corresponding to ERD files, which may be files used to store modeling information, i.e., attributes about tables and modeling information about relationships between tables stored in the DB130, a UI object corresponding to each of at least one SQL file included in the target source bundle, and a UI object corresponding to a design file included in the target source bundle; a step of providing an ERD file editing function for editing the ERD file when a UI object corresponding to the ERD file is selected; a step of providing an SQL file editing function for editing an SQL file corresponding to the selected UI object when the UI object corresponding to one of the at least one SQL file is selected; a step of providing a design file editing function for editing the design file when a UI object corresponding to the design file is selected; and providing the user-defined ERP function based on at least one of the SQL file and the design file.

According to another aspect of the present invention, there is provided a computer program installed in a data processing apparatus and stored in a recording medium for executing the method.

According to another aspect of the present invention, there is provided a user-defined ERP function sharing system, the user-defined ERP function sharing system including at least one processor; and a memory for storing a computer program for execution by the processor, wherein the computer program, when executed by the processor, causes the user-defined ERP function sharing system to perform a user-defined ERP function sharing method.

ADVANTAGEOUS EFFECTS OF INVENTION

According to embodiments of the present invention, a method and system are provided that provide an integrated development environment to develop database modeling as a whole, SQL queries and UIs for manipulating the database, enabling custom ERP individual functions that are tailored to an enterprise to be easily generated.

And a method and system are provided that allow users to easily share self-developed ERP functions with others.

Drawings

In order that the detailed description of the invention may be understood more fully, a simplified description of each schematic is provided.

FIG. 1a is an operational environment diagram illustrating a method of generating user-defined ERP functions according to an embodiment of the present invention.

Fig. 1b is a block diagram schematically illustrating a user terminal configuration according to an embodiment of the present invention.

Fig. 2 is a schematic diagram illustrating a process of generating user-defined ERP functions by a user terminal according to an embodiment of the present invention.

Fig. 3 is a diagram illustrating an example of a UI of an integrated development environment provided by a user terminal according to an embodiment of the present invention.

Fig. 4 is a diagram showing an example of a program window.

Fig. 5 is a diagram showing an example of a database search window.

Fig. 6 is a flowchart schematically illustrating a process in which the generation system performs an ERD file editing function according to an embodiment of the present invention.

Fig. 7 is a diagram showing an example of an ERD file editing UI.

Fig. 8 is a flowchart schematically showing a procedure in which a user terminal performs an SQL file editing function according to an embodiment of the present invention.

Fig. 9 is a diagram showing an example of an SQL file editing UI.

Fig. 10 is a flowchart schematically showing a procedure in which a user terminal performs a design file editing function according to an embodiment of the present invention.

Fig. 11 is a diagram showing an example of the design file editing UI.

Fig. 12 is a diagram showing an example of a tool box window.

Fig. 13 is a diagram showing an example of an attribute window.

Fig. 14 is a diagram showing an example of a script window.

Fig. 15a to 15e are diagrams showing examples of the SQL mapping UI.

Fig. 16 is a flow chart schematically illustrating the mapping process between SQL and controls.

Fig. 17 is a diagram illustrating an example of a user-defined ERP function sharing system and a process of sharing a user-defined ERP function through a user terminal according to an embodiment of the present application.

Fig. 18 is a diagram showing an example of a source package upload UI.

Fig. 19 is a diagram showing an example of a source package download UI.

Detailed Description

While the application is susceptible to various modifications and alternative embodiments, specific embodiments have been shown in the drawings and will be described in detail herein. The application should be understood to be not limited to the particular embodiments, but to include all modifications, equivalents and alternatives falling within the spirit and technical scope of the application. In describing the present application, detailed descriptions of known techniques are omitted if they are determined to obscure the gist of the present application.

The terms first, second, etc. may be used to describe various components and the components should not be limited by the terms. These terms are only used to distinguish one element from another element.

The terminology used in the present application is for the purpose of describing particular embodiments only and is not intended to be limiting of the application. Singular expressions include plural expressions unless the context clearly indicates otherwise.

In this specification, the terms "comprises" or "comprising," and the like, mean that the recited features, numbers, steps, operations, elements, components, or combinations thereof are present, but should be understood to not preclude the possibility of the presence or addition of one or more other features, numbers, steps, operations, elements, components, or combinations thereof.

In addition, in this specification, when any one of the constituent elements "transmits" data to another constituent element, the constituent element may transmit the data directly to the other constituent element, or may transmit the data from the constituent element to the other constituent element through at least one other constituent element. In contrast, when one component "directly transmits" data to another component, this means that the data is transmitted from the component to the other component without passing through the other component.

Hereinafter, the present invention will be described in detail according to embodiments of the present invention with reference to the drawings. Like reference numerals in the drawings denote like elements.

FIG. 1a is a schematic diagram illustrating an operating environment of a user-defined ERP function generation method according to an embodiment of the present invention. Referring to fig. 1a, a plurality of user terminals (100-1 to 100-N) and a user-defined ERP function sharing system 200 (hereinafter, referred to as a "sharing system") are connected through a wired/wireless network, and a user-defined ERP function generating method according to an embodiment of the present invention may be performed. A plurality of user terminals (100-1 to 100-N) may share source packages corresponding to ERP user-defined functions through the sharing system 200.

For example, each user terminal (100-1 through 100-N) may create a source package corresponding to a user-defined ERP function and upload it to the sharing system 200 for sharing with others. Hereinafter, a user terminal uploading a source packet will be referred to as a sharer terminal.

The uploaded source packages may be stored in a predetermined repository 210. The repository 210 may be a device that stores source packages uploaded to the sharing system 200. The repository 210 may be a database or a memory device. The repository 210 may be a component included in the shared system 200, but is not limited thereto, and may be a physical device separate from the shared system 200, as shown in fig. 1 a.

On the other hand, each of the user terminals (100-1 to 100-N) may download a portion of the plurality of source packages stored in the repository 210 of the sharing system 200.

The user terminal 100 may be a handheld device such as a mobile phone, satellite phone, wireless phone, session initiation protocol (SIP: session Initiation Protocol), wireless local loop (WLL: wireless Local Loop) station, smart phone, tablet computer, palm top computer (PDA: personal Digital Assistant), etc., as well as a desktop or notebook computer.

The sharing system 200 may include hardware resources (resources) and/or software necessary to implement the technical ideas of the present invention, and does not necessarily mean one physical component or a single device. That is, the sharing system 200 may represent a logical combination of hardware and/or software provided to implement the technical ideas of the present invention. And may be installed in separate devices to perform respective functions if necessary, so as to be embodied as a set of logic combinations for realizing the technical idea of the present invention. The sharing system 200 may be represented as a combination of elements individually embodied for each function or role for realizing the technical idea of the present invention.

The sharing system 200 may be implemented in the form of a plurality of modules. For example, the sharing system 200 may include at least one communication module capable of communicating with various user terminals (100-1 to 100-N) through a network, or a control module performing a main function of the sharing system 200 and capable of controlling functions and/or resources of other components included in the sharing system 200, and a storage module capable of storing various information, an input/output module capable of interfacing with a user, and the like. The various modules included in the sharing system 200 may be located in different physical devices or may be located in the same physical device.

In the present specification, the modules may represent functional and structural combinations of hardware for executing the technical ideas of the present invention and software for driving the hardware. For example, the modules may represent predetermined code and logic elements of hardware resources for executing the predetermined code, and an average person of ordinary skill in the art can readily infer that it does not necessarily represent physically connected code or a piece of hardware.

Fig. 1b is a block diagram schematically illustrating a configuration of a user terminal 100 according to an embodiment of the present invention. Referring to fig. 1b, the user terminal 100 includes a user-defined ERP function generating module 110 (hereinafter, referred to as a "generating module"), the user-defined ERP function driving module 120 (hereinafter, referred to as a "driving module"), and a user-defined ERP function sharing module 140 (hereinafter, referred to as a "sharing module").

In some cases, the user terminal 100 may further include a DB130 for storing various data and company various information required to implement the technical ideas of the present invention.

Fig. 1b shows an example in which the DB130 is included in the user terminal 100. However, in other embodiments, the DB130 may be in a separate system form physically separated from the user terminal 100, unlike this. In this case, the user terminal 100 and the DB130 may be connected to each other via a network to transmit and receive various data and information. Further, according to an embodiment, the user terminal 100 may operate with a plurality of DBs included in the user terminal 100 or connected through a network.

In this specification, a DataBase (DB: dataBase) may be implemented by at least one table, and may also mean a separate DataBase management system (DBMS: database Management System) further including a DataBase for searching, storing, and managing information stored in the DB. In addition, it may be implemented in various ways, such as a linked-list (Tree), a relationship DB, etc., and may represent all data storage media and data structures including information that can be stored in the DB 130.

The generation module 110 may generate user-defined ERP functions or edit previously created user-defined ERP functions. The driver module 120 may drive the user-defined ERP functions generated by the generator module 110 to provide the user-defined ERP functions to the user. The sharing module 140 may upload the user-defined ERP functions generated by the generating module 110 to the sharing system 200 and share the user-defined ERP functions with other users, or may download the user-defined ERP functions shared by others from the sharing system 200.

The generation module 110, the driving module 120, and the sharing module 140 may be designed as separate physical devices. Alternatively, the modules 110, 120, 140 may be designed as one physical device, according to an embodiment. In the latter case, each of the three modules 110, 120 and 140 may be configured as separate logically separate software, or may be designed as one integrated software.

Hereinafter, for convenience of understanding, the present invention will be described as a generating function of a user-defined ERP function performed by the generating module 110, a driving function of the generated user-defined ERP function performed by the driving module 110, and a sharing function of the user-defined ERP function performed by the sharing module 140 according to the technical idea of the present invention, however, the user terminal 100 may be implemented by one system that comprehensively performs the generating function of the user-defined ERP function, the driving function of the generated user-defined ERP function, and the sharing function of the user-defined ERP function according to the technical idea of the present invention, according to different embodiments, as different from FIG. 1 b.

The user-defined ERP functionality may be integrated into the ERP system, and may be a unit functionality with its own independent meaning. The user-defined ERP function may perform functions of managing, operating, using, and analyzing the enterprise information stored in the DB 130. A customized User Interface (UI) may be provided that allows the User to perform these functions. That is, the user can manage, operate, use, and analyze the enterprise information stored in the DB130 through the UI provided by the user-defined ERP function.

Examples of user-defined ERP functions are voucher entry, account book management, account up and down management, credited account age analysis/management, settlement management, financial statement, fund/budget management, budget versus usage analysis, fixed asset management, additional tax declaration management, financial special house management, human resource management, attendance management, payroll management, social insurance management, annual end settlement management, refund settlement management, tax declaration management, different resulting voucher processing, temporary work management, domestic sales planning/management, quote/order processing, commission/check management, ex-warehouse/return management, sales contribution analysis, delivery/distribution management, temporary ex-warehouse/commission management, sales settlement, electronic tax calculation processing, collection/credited management, credited account analysis, export planning/management, order management, ex-warehouse management, sales settlement, shipment management, intrinsic endowment/order processing, shipment/receipts management, import cost processing, un-delivery settlement processing, import cost allocation, main production planning (MPS), calculation of required materials, application of endowment/order, warehouse entry commission/inspection, temporary warehouse entry management, buy settlement/accounting, payment/liability management, inventory management (LOT), production planning/management, internal production management, hybrid process management, byproduct/disassembly management, agent production management, production guidance management, outsourcing management, service reception/processing, service right management, financial/profit/loss analysis, loss/gain analysis, main financial analysis, logistic summary analysis, sales analysis of different characteristics, seasonal production performance analysis, attendance analysis of different characteristics, payroll/prize simulation, contract management, field management, subcontracting/finishing management, job date reporting, advance payment/payment management, labor equipment management, settlement management, labor reporting management, outsourcing finishing management, cost effectiveness management, etc., but in addition, many functions are possible.

As shown in fig. 1b, the user terminal 100 is connected to the sharing system 200 through a network, and can transmit and receive various information, data, signals, and/or messages required to implement the technical ideas of the present invention.

The user terminal 100 may transmit the result created through the generation function of the user-defined ERP function to the sharing system 200, and the sharing system 200 may provide (transmit) it to other desired users. That is, the sharing system 200 may perform a function of sharing the user-defined ERP function uploaded by each user to other users.

The results generated by the generation function of the ERP function may include an ERP file, at least one SQL file, and a design file, and may also include a report file according to an embodiment.

The ERD file may be a file for storing modeling information, i.e., attributes about tables and modeling information about relationships between tables, which are stored in the DB 130.

The entity-relationship model (ERD: entity Relationship Diagram) is the most commonly used data modeling technique. It uses simple shapes (rectangular, oval, diamond, etc.) to express the structure and relationship of data, and is most commonly used as a tool for patterning relationships and attributes among data individuals. The user can more easily understand the relationship of the data visually by illustrating the relationship using ERD. The components of ERD are entities (entities), relationships (relationships), and attributes (attributes). The entity means a body as information to be stored in a database or a separate entity as an object. In database modeling, a table stored in a database may be an entity. A relationship indicates how two or more entities are related to each other. An attribute is a data item that describes a characteristic of an entity or relationship. The attribute that can uniquely identify each entity is referred to as a key attribute.

The SQL file may be a file storing a structured query language (SQL: structured Query Language) query for manipulating the DB 130. Each SQL file may store one or more SQL queries.

SQL is a programming language designed for special purposes, i.e., managing data of a database management system (DBMS), and can be used to create queries for searching and managing materials stored in a database, creating and modifying database schemas, access control management of database objects, and the like. SQL commands can be divided into three types according to their functionality: data operations (DML), data Definitions (DDL), and Data Control (DCL). Data Manipulation (DML) is a command for changing data or searching data in a database, and there are INSERT (add data), UPDATE (UPDATE data), DELETE (DELETE data), SELECT (search data), and the like. The Data Definition (DDL) is a command for changing the structure of a table or the like containing data, and includes CREATE (e.g., generation table), DROP (e.g., deletion table), ALTER (e.g., change table structure), and the like. Data Control (DCL) is a command to GRANT or REVOKE access to a database, and there are GRANT (GRANT of user rights), revole (REVOKE of user rights), and the like.

The design file may be a file storing information about at least one control attribute constituting a user-defined ERP function interface. Here, the control may be a UI object capable of performing interaction with the user, such as displaying information or receiving information by the user, or the like.

Additionally, at least a portion of the controls that make up the user-defined ERP functionality interface may be controls that map to specific queries included in the at least one SQL file. Hereinafter, such controls will be referred to as grid controls.

The report file may include information about attributes of a plurality of controls constituting the report electronic document and information about data bound to each control.

As shown in fig. 2, the generating module 110 may provide a container UI including a UI object corresponding to an ERD file, a UI object corresponding to at least one SQL file, and a UI object S110 corresponding to a design file, and the user may select any one of the UI objects S120 included in the container UI.

The generation module 110 may provide an ERD file editing function S130 for editing the ERD file if a UI object corresponding to the ERD file is selected.

If a UI object corresponding to the SQL file is selected, the generation module 110 can provide an SQL file editing function S140 for editing the SQL file.

If a UI object corresponding to the design file is selected, the generation module 110 may provide an ERD file editing function S150 for editing the design file.

At the same time, the generation module 110 may provide an integrated development environment so that users may create and customize user-specified ERP functions. Using the provided integrated development environment, a user may create or edit ERD files, SQL files, design files, and report files required to drive user-specified ERP functions.

A user may generate a plurality of user-specified ERP functions by creating the module 110, wherein the plurality of user-specified ERP functions may be managed as a corresponding item, respectively. Each item may be a package or container containing at least one SQL file and a design file.

Even with multiple items, there may be only one ERD file. In this case, a common ERD file may be used by a plurality of user-specified ERP functions generated by the plurality of items.

Hereinafter, a method of a user to create/edit user-specified ERP functions through an integrated development environment will be described in detail.

Fig. 3 is a diagram showing an example of a UI of the integrated development environment provided by the generation module 110.

As shown in fig. 3, the integrated development environment UI1000 includes a menu 1100, a project window 1200, a database search window 1300, an editor window 1400, a tool box window 1500, an attribute window 1600, and a script window 1700.

The menu 1100 may include a plurality of icons, and each icon may be a UI object for performing functions frequently used by a user, including creating new items, opening files, saving files, copying and pasting, and the like.

The item window 1200 may be a container UI including UI objects (e.g., icons) corresponding to ERD files, UI objects corresponding to at least one SQL file, respectively, and UI objects corresponding to design files.

Fig. 4 is a diagram showing an example of the project window 1200.

As shown in fig. 4, a UI object 1211 corresponding to an ERD file may be displayed in the item window 1200, and when the user selects the UI object 1211 corresponding to the ERD file (e.g., when clicking, double clicking, or touching the UI object, etc.), the generation module 110 may provide an ERD file editing function for editing the ERD file. The generation module 110 may display a UI for editing the ERD file in the editor window 1400 to provide an ERD file editing function, and the user may edit the ERD file on the UI displayed in the editor window 1400.

The UI object 1211 corresponding to the ERD file may be displayed at a lower level of the ERD container UI object 1210. The user may interact with the ERD container UI object 1210 in a predetermined manner to generate a new ERD file, and may add a UI object corresponding to the newly created ERD file to a lower level of the ERD container UI object 1210. At this time, the newly created ERD file may be a blank (blank) file that does not contain any information.

In the item window 1200, UI objects 1201, 1202, and 1203 respectively corresponding to at least one item may be displayed, and each item may correspond to a different user-defined ERP function.

As described above, each item may be a container including at least one SQL file and a design file, at least one report file, and the item window 1200 may display UI objects 1221 and 1222 corresponding to the at least one SQL file, respectively, UI object 1231 corresponding to the at least one report file, UI object 1241 corresponding to the design file, respectively, belonging to each item (e.g., 1202).

UI objects 1221 and 1222 corresponding to at least one SQL file, respectively, may be displayed at a lower level of the SQL container UI object 1220. The user may interact with the SQL container UI object 1220 in a predetermined manner to generate a new SQL file, and may add a UI object corresponding to the new SQL file to a lower level of the SQL container UI object 1220. At this point, the newly created SQL file may be an empty file that does not contain any information.

UI objects 1231 respectively corresponding to the at least one report file may be displayed at a lower level of the report container UI object 1230. The user may interact with the report container UI object 1230 in a predetermined manner to generate a new report file, and may add a UI object corresponding to the new report file to a lower level of the report container UI object 1230. At this time, the newly created report file may be an empty file that does not contain any information.

Meanwhile, when the user selects a UI object (e.g., 1221) corresponding to any one of the at least one SQL file, the generation module 110 may provide an SQL file editing function to edit the SQL file corresponding to the selected UI object 1221. The generation module 110 may display a UI for editing an SQL file in the editor window 1400 to provide an SQL file editing function, and the user may edit the SQL file on the UI displayed in the editor window 1400.

Further, when the user selects a UI object (e.g., 1231) corresponding to any one of the at least one report file, the generation module 110 may provide a report editing UI for editing the report electronic document. The generation module 110 may display a UI for editing a report file in the editor window 1400 to provide a report file editing function, and a user may edit the report file on the UI displayed in the editor window 1400.

In addition, when the user selects the UI object 1241 corresponding to the design file, the generation module 110 may provide a design file editing function for editing the design file. The generation module 110 may display a UI for editing the design file in the editor window 1400 to provide a design file editing function, and the user may edit the design file on the UI displayed in the editor window 1400.

Meanwhile, the user may interact with the UI object (e.g., 1202) corresponding to the specific item in a predetermined manner to generate a new design file, and add the UI object corresponding to the newly created design file to a lower level of the UI object 1202 corresponding to the item. At this time, the newly created design file may be an empty file that does not contain any information.

Although the above describes an example in which the generation module 110 provides each file editing function through the editor window 1400 included in the integrated development environment UI1000, the generation module 110 may execute a separate application corresponding to its respective file editing function according to different embodiments, in which case a user may edit the respective file on the application.

Fig. 5 is a diagram showing an example of a database search window 1300.

As shown in fig. 5, the database search window 1300 may include UI objects 1310 and 1320 corresponding to the DB130 connected to the user terminal 100 or the generation module 110.

The UI object (e.g., 1310) may have UI objects (1311 to 1313) displaying at least one mode as lower levels thereof. Schema as a structure of data, a method of expressing data, a structure defined by a format language or a namespace of a relation between data in a database, may be a container containing objects such as tables, stored procedures, and the like. Accordingly, as a lower level of UI objects displaying a specific pattern, UI objects corresponding to each object such as a table or a stored procedure included in the pattern may be included.

A table refers to a data set composed of items, i.e., fields, for storing various data, and one database may be composed of several tables. A save process or store process (stored procedure) is a collection of queries that execute a series of queries like a function, storing a process on a database in a database management system, also referred to as a persistent storage module (Persistent Storage Module).

In the editor window 1400, an edit UI corresponding to the type of the file selected by the user may be displayed.

Fig. 6 is a flowchart schematically showing a procedure in which the generation module 110 performs the ERD file editing function.

Referring to fig. 6, if the user selects an object corresponding to the ERD file, the generation module 110 may provide an ERD file editing UI S131. In one embodiment, the generation module 110 may display an ERD file editing UI in the editor window 1400. At this time, the ERD file editing UI may include a table structure UI object displaying the structure of the database table and a relationship UI object displaying the relationship between the tables.

The generation module 110 may then alter the table structure and the relationship between the table structures based on user input on the ERD file editing UI S132. When the change is completed, the relationship between the changed table structure and the table may be reflected in the ERD file S133.

Hereinafter, the process of fig. 6 will be described in more detail with reference to fig. 7.

The generation module 110 may provide an ERD file editing UI2000 through the editor window 1400 based on the content of an ERD file corresponding to the user-selected ERD file object.

Fig. 7 is a diagram showing an example of the ERD file editing UI2000.

As shown in fig. 7, the ERD file editing UI2000 includes a toolbar UI2100, which may include buttons for creating a new table, buttons for creating a new relationship, and buttons for reflecting changes to the DB 130. ERD file editing UI2000 also includes a table structure UI object (e.g., 2210, 2220, 2230) that displays the structure of the database table and a relationship UI object (e.g., 2310, 2320) that displays the relationship between tables.

The table structure UI objects 2210, 2220, and 2230 may display corresponding column information included in the table.

The relationship UI objects 2310 and 2320 may be in the form of lines connecting two table structure UI objects (2210 and 2220). The relationship UI object may be represented in different forms (e.g., solid or dashed lines) depending on whether the relationship between the two tables is an identified relationship or a non-identified relationship.

The generation module 110 may alter the table structure and the relationship between the table structures based on user input on the ERD file editing UI.

The user may create a new table UI object on ERD file editing UI 2000.

The user may create a UI object corresponding to the table that has been created in the DB 130. To this end, the user may select a UI object corresponding to a specific table displayed in the database search window 1300 or input a command such as drag and drop on the ERD file editing UI2000, and in response, the generation module 110 may create a new table UI object corresponding to the table in the ERD file editing UI 2000. Alternatively, the user may select a new table generation UI provided by the ERD file editing UI2000 to create a UI object corresponding to the new table.

On the other hand, the user may delete a table UI object existing on the ERD file editing UI2000 or change the structure of the table (e.g., add/delete/change of a column or change an attribute of a table) through the corresponding table UI object.

The user may also create a new relationship UI object to display the relationship between the table UI objects present on ERD file editing UI 2000. For example, the user may select a button provided by the ERD file editing UI2000 for creating a new relationship and then create a new relationship UI object that displays the relationship between the two selected tables by selecting the two tables that need to be related to each other.

On the other hand, the user may delete the relationship UI object existing on the ERD file editing UI2000 or change the relationship information through the relationship UI object.

After the database modeling is altered by the above-described process, for example, when the user presses a designated save button, the generation module 110 may reflect the altered table structure and the relationship between the table structures in the ERD file.

In addition, the generating module 110 may reflect the changed table structure and the relationship between the table structures in the relationship DB130, change the table structure of the DB130, add a new table, or delete an existing table.

Fig. 8 is a flowchart schematically showing a procedure in which the generation module 110 performs the SQL file editing function.

Referring to fig. 8, if the user selects an object corresponding to an SQL file, the generation module 110 may provide an SQL editing UI S141. In one embodiment, the generation module 110 may display an SQL editing UI in the editor window 1400.

The generation module 110 may then alter the SQL query S142 according to user input on the SQL editing UI. When the change is completed, the changed query may be reflected in the SQL file S143.

Hereinafter, the process of fig. 8 will be described in more detail with reference to fig. 9.

If the user selects an object corresponding to an SQL file, an SQL file editing UI3000 may be displayed in the editor window 1400. That is, the generation module 110 may provide the SQL file editing UI3000 through the editor window 1400, which displays the contents of the SQL file corresponding to the SQL file object selected by the user.

Fig. 9 is a diagram showing an example of the SQL file editing UI3000.

As shown in fig. 9, the SQL file editing UI3000 includes a toolbar UI3100 including a UI for selecting a DB to be connected, a button for executing connection with the DB, a button for releasing connection, and a UI for selecting whether a created query is insert or update.

In addition, the SQL file editing UI3000 may include an editing UI3200 for creating queries, and a user may create or edit SQL queries on the editing UI 3200. The user may include the parameter variable name at the time the query is created. For example, the parameter variable name may be in the form of "@ variable name". The variable names may be used for links to controls and queries on the function screen editing UI, which will be described below. To this end, at least a portion of the controls contained in the design file may be mapped to the parameter variable names. On the other hand, when the SQL query is subsequently executed, data entered on the control mapped to the argument variable name may be input to the SQL query. More specifically, data entered on the control mapped to the argument names may be assigned to the argument names of the SQL query.

The toolbar UI3200 may include buttons for executing the created query, and the SQL file editing UI3000 may include a result display UI3300 for displaying the execution result thereof. On the results display UI3300, the structure of the table and the data searched by the query may be displayed.

Meanwhile, when the SQL query is changed through the above-described procedure, for example, when the user presses a designated save button, the generation module 110 may reflect the changed SQL query in the SQL file.

Fig. 10 is a flowchart schematically showing a procedure in which the generation module 110 performs a design file editing function.

Referring to fig. 10, when the user selects an object corresponding to a design file, the generation module 110 may provide a function screen editing UI S151. In one embodiment, the generation module 110 may display a function screen editing UI in the editor window 1400.

Next, the generating module 110 may change controls and properties of the controls for constructing a screen of the user-defined ERP function according to the user' S input on the function screen editing UI S152.

The generation module 110 may then reflect the changed controls that make up the user-defined ERP function screen, the changed properties of the controls, and the mapping information between the changed controls and the query to the design file S153.

Hereinafter, the process of fig. 10 will be described in more detail with reference to fig. 11 to 14.

If the user selects an object corresponding to the design file, a design file editing UI may be displayed in the editor window 1400. That is, the generation module 110 may provide a design file editing UI through the editor window 1400 based on a design file corresponding to a design file object selected by a user.

Fig. 11 is a diagram showing an example of the design file editing UI4000.

Various controls (e.g., 4010 through 4040) that have been previously defined in the design file may be displayed in the design file editing UI4000.

The user may delete a control displayed in the design file edit UI4000, change the layout, or modify the outline element, e.g., size.

The user may also add new controls to the design file editing UI4000. To this end, the generation module 110 may provide a toolbox window 1500 for selecting various controls. Fig. 12 is a view showing an example of the tool box window 1500.

As shown in fig. 12, the toolbox window 1500 may include various types of controls, and the user may place the control into the design file editing UI4000 by selecting the desired control or dragging and dropping it into the design file editing UI4000.

Meanwhile, in the tool box window 1500, various controls may be classified into specific categories according to predetermined classification criteria. For example, as shown in FIG. 12, a generic control 1510 commonly used in GUIs, a business control 1520 specially used in the ERP field, a data control 1530, a layout control 1550 and a pop-up control 1570 for constructing a screen layout and for use as containers for other controls, and the like.

In particular, controls belonging to the data control class 1530 (hereinafter, "data controls") can perform functions that display data searched by the SQL query. The data controls have a flexible Grid (Flex Grid) shown in the form of a data table, a Pivot Grid (Pivot Grid) shown in the form of a Pivot table, and a Chart Grid (Chart Grid) shown in the form of a Chart searched by the SQL query. In addition, there are various types of data controls. The data control 4040 of fig. 11 is one example of a flexible grid.

On the other hand, when the user selects (e.g., clicks on) a control placed in the design file editing UI4000 in a predetermined manner, an attribute value of the selected control may be displayed in the attribute window 1600, and the user may change the attribute value of the control shown in the attribute window 1600. Fig. 13 is a diagram showing an example of an attribute window 1600.

Further, when the user selects (e.g., double-clicks) a control provided in the design file editing UI4000 in a predetermined manner, the script window 1700 may display a method script of an action to be performed by a specific event, and the user may create/edit the method script displayed in the script window 1700. Fig. 14 is a diagram showing an example of a script window 1700.

As shown in fig. 14, script window 1700 includes UI1710 for selecting any one of the controls arranged in design file editing UI4000, UI1720 for selecting events that can occur in the controls, UI1730 for creating a method script to be executed when the selected event occurs in the selected control.

In addition, if the controls, the attributes of each control, and/or the method script constituting the user-defined ERP function screen are changed through the above-described process, for example, when the user presses a designated save button, the generation module 110 reflects the change item to the design file.

Meanwhile, the generation module 110 may perform a mapping process such that content displayed on the user-defined ERP function screen is associated with the SQL query. That is, the generation module 110 provides an SQL mapping UI for mapping at least a portion (e.g., 4040) of the data controls displayed in the design file editing UI4000 to at least one particular query included in an SQL file. And mapping at least a portion of the controls displayed in the control editing UI to at least one particular query included in the SQL file according to user input on the SQL mapping UI. Fig. 15a to 15e are diagrams showing examples of the SQL mapping UI.

Fig. 15a is a diagram showing the current SQL mapping state. The SQL map UI5000 shown in FIG. 15a may include a UI5010 that displays a list of queries defined in at least one SQL file corresponding to user-defined ERP functions. In the example of FIG. 15a, a predetermined data control may be mapped to a query named SQL. Through the SQL mapping UI5000, a user can map input controls (controls that can receive data from the user) to parameters described in an SQL query, and can map data controls for displaying the query results to the SQL query. Further, when the user changes the value displayed on the data control or adds/deletes a column, it may be arranged to execute a separate query, as will be described in more detail below.

In fig. 15a, when "query settings 5020" of the SQL query are selected, the UI5100 shown in fig. 15b may be displayed. On the UI5100 as shown in fig. 15b, the user can map specific controls (e.g., 4010 and/or 4030) included in the design file editing UI4000 to each argument variable name included in the SQL statement. The control mapped to the parameter variable name may be a control (input control) that performs a function of receiving data from a user. As shown in fig. 15b, the UI5100 may include a list 5110 listing each argument variable name contained in the SQL statement, and may further include UIs (e.g., 5101 to 5103) for selecting controls mapped to the respective argument variable names.

In the example of fig. 15b, bpComboBox1 (4010) maps to @ multiModule and textbox ext1 (4030) maps to @ keyword. As described above, when a specific control included in the design file editing UI4000 is mapped to a argument name in an SQL query, data input on the control mapped to the argument name when the SQL query is subsequently executed may be input to the SQL query.

When "control settings 5030" is selected in fig. 15a, the UI5200 shown in fig. 15c may be displayed. The UI5200 may include a UI5210 for selecting a data control displayed on the design file editing UI 4000. This allows the user to select a data control (e.g., 4040) to map to the SQL query.

The UI5200 also includes a UI5220 for executing customization, such as a column to be selected for use/output among columns included in a DB table searched by an SQL query, adjusting a display order, setting a display format of each field, and the like.

When "binding settings 5040" in fig. 15a is selected, the UI5300 shown in fig. 15d may also be displayed. On the UI5300 as shown in fig. 15d, the user can map columns included in the DB table to be searched by the SQL query using specific controls included in the design file editing UI 4000.

In the case where "save settings 5050" in fig. 15a is selected, the UI5400 shown in fig. 15e may also be displayed. The UI5400 shown in fig. 15e includes a UI 5410 for selecting an SQL query that can cause a record inserted through a data control to be inserted into a database, a UI5420 for selecting a query that can update data changed on the data control, and a UI5430 for selecting a query that performs deletion of a record.

Fig. 16 is a flowchart schematically showing the above-described mapping process.

In one embodiment, the generation module 110 can display each SQL query S210 included in at least one SQL file.

When the user selects one of the displayed SQL queries, the selected SQL query may be analyzed to obtain parameter variable names S220 included in the SQL query, and the obtained parameter variable names S230 may be displayed.

Then, according to the user' S input, the generation module 110 may map the control (e.g., 4010 or 4030) displayed in the design file editing UI4000 to each of the displayed parameter name variables S240.

In addition, the generation module 110 can map any data controls (e.g., 4040) displayed in the design file editing UI4000 to the SQL query selected by the user input (S240, S250).

Referring again to FIG. 1b, the driver module 120 may drive the user-defined ERP functions generated by the generator module 110 to provide the user-defined ERP functions to the user.

As described above, the generation module 110 may generate at least one SQL file and a design file corresponding to the user-defined ERP function, and the driving module 120 may interpret it to drive the user-defined ERP function. The driving module 120 may be an engine that receives a metadata or script and performs a corresponding operation.

For example, the driving module 120 may configure a screen of the user-defined ERP function using information about various controls included in the design file and display the screen. In addition, when a user inputs a specific command or data to a control, the driving module 120 may perform a corresponding method, script, or built-in function. The driving module 120 may execute the SQL query mapped with the data control and reflect the execution result to the data control or the DB130. In addition, the driver module 120 may execute various instructions to enable user-defined ERP functions to operate properly.

The sharing module 140 may perform user-defined ERP sharing functions, which will be described below.

Fig. 17 is a diagram illustrating an example of a process in which the user terminal 100 and the sharing system 200 share a user-defined ERP function. Fig. 17 shows an example of sharing one user-defined ERP function between two terminals for convenience of description, but needless to say, a plurality of user-defined ERP functions may be shared between a plurality of terminals.

Referring to fig. 17, a process of sharing a user-defined ERP function between two terminals 100-1 and 100-2 can be roughly divided into a source package upload process (S310 to S340) and a source package download process (S350 to S370).

First, explaining the source package upload procedure, the sharer terminal 100-1, which wants to share the user-defined ERP function with another person, may provide a source package upload UI (S310). The source package upload UI may provide a selection function to select user-defined ERP functions to be transmitted to the sharing system 200. Items corresponding to a plurality of user-defined ERP functions may be stored in the sharer terminal 100-1, and a user may select an item among which sharing is desired through the source package upload UI.

Some or all of the items stored in the sharer terminal 100-1 may be pre-generated through the user-defined ERP generation process. Alternatively, some or all of the items stored in the sharer terminal 100-1 may be downloaded to the sharer terminal 100-1 by a source package download function described later.

The source package may correspond to a user-defined ERP function and may include at least one SQL file and a design file corresponding to the user-defined ERP function. According to a specific embodiment, the source package may further include an ERD file.

The source package may also include additional information regarding the corresponding user-defined ERP function. The additional information may include any information related to the user-defined ERP function, such as a name, description information (description), author, sharer and/or screen shot, category information, etc. of the user-defined ERP function.

Fig. 18 is a diagram showing an example of a source package upload UI 6000.

The source package upload UI6000 may include a list 6100 of user-defined ERP function items stored in the sharer terminal 100-1. Each list includes a UI object (e.g., 6010) for selecting whether to upload, a UI object (e.g., 6020) for displaying a project name (or a name of a user-defined ERP function), a UI object (e.g., 6030) for recording detailed description information, a UI object (e.g., 6040) for selecting whether to disclose, a UI object (e.g., 6050) for designating a screenshot, and the like. In addition, the source package upload UI may further include a UI object for inputting/designating various additional information that may be included in the source package.

The user may select some of the seven items (Project 1 and Project2 in the example of fig. 18), as shown in fig. 18. After selecting the item to be shared, the user may select a button 6200 for performing uploading and instruct the sharer terminal 100-1 to perform uploading.

Referring back to fig. 17, the sharer terminal 100-1 may generate a source package S320 corresponding to the user-defined ERP function selected by the user, and may transmit the source package to the sharing system 200 (S330).

The sharing system 200 may then store the received source packets in the predefined repository 210S 340.

Meanwhile, according to an embodiment, the sharing system 200 may sort and store the received source packets according to a specific standard. To this end, the sharing system 200 may determine to which of a predefined plurality of categories the user-defined ERP function corresponding to the received source package belongs, and categorize the source package into the category to which the user-defined ERP function corresponding thereto belongs and store them in the repository 210. The predefined plurality of categories may include categories commonly used in the ERP field. For example, these categories may include accounting, personnel, sales, procurement/materials, outsourcing, trade, services, construction, production, standards, costs, consolidated accounting, and the like.

The category to which the user-defined ERP function belongs may be specified by the sharer.

Alternatively, the category to which the user-defined ERP function belongs may be determined by the sharing system 200. The sharing system 200 may analyze at least one SQL file included in the source package or a design file included in the source package to determine which category the user-defined ERP function belongs to, and determine which of a plurality of categories the user-defined ERP function corresponding to the source package belongs to based on the analysis result. For example, the sharing system 200 may analyze the names or other information of databases, tables or fields, and/or parameters described in queries of SQL files included in the source package. The sharing system 200 may analyze various information (e.g., control names or attributes, etc.) described in the design files included in the source package.

The source package download process is described below. If the user terminal 100-2 accesses the sharing system 200 or requests to provide a list to download various user-defined ERP functions shared by others, the sharing system 200 may transmit the source Bao Liebiao stored in the repository 210 to the user terminal 100-2 (S350).

Then, the user terminal 200 may provide a source package download UI (S360). The source package download UI may display a list of received source packages and may provide functionality to select at least some items of the received source package list.

Fig. 19 is a diagram showing an example of a source package download UI 7000. Referring to fig. 19, the source package download UI7000 may include a list UI7100 to display a list of source packages received from the sharing system 200. Each item of the list UI7100 may include information of a name of a source package, a name of a user-defined ERP function corresponding thereto, a representative icon, a registration date, and the like. In addition, the source package download UI7000 may further include a detailed information display UI7200 to display detailed information of the source package selected by the user. The detailed information display UI7200 may include a name of an application (e.g., the driver module 120) to which the user-defined ERP function corresponding to the corresponding source package is applicable, a name of a registrant, a name of the user-defined ERP function corresponding thereto, a detailed description, etc. In addition, the detailed information display UI7200 may display a screenshot 7210 of a user-defined ERP function. The screen shots may be images specified by the sharer sharing the source package.

Or screenshot 7210 may be an image generated by the sharing system 200. For example, the sharing system 200 may perform the functions of the driving module 200 described above. After performing the user-defined ERP function using the SQL files and design files contained in the source package, a photograph is taken.

Meanwhile, the source package download UI7000 may further include a category UI7300 for displaying a category list to which the user-defined ERP function may belong. When the user selects any one of the categories included in the category UI7300, the list UI7100 may display only the source package list corresponding to the user-defined ERP function belonging to the selected category.

The source package download UI7000 may further include an upload button 7400. When the upload button 7400 is selected, the user terminal 100-2 provides the source package upload UI6000, allowing the user terminal 100-2 to share user-specified ERP functions with others.

In addition, the source package download UI may further include a button UI7410 for requesting download of the source package selected by the user. When the user selects the button UI7410, the user terminal 100-2 may request the download source package from the sharing system 200.

Referring back to fig. 17, in response to the download request of the user terminal 100-2, the sharing system 200 transmits a target source packet selected by the user terminal from among source packets stored in the storage library 210 to the user terminal 100-2 (S370).

Meanwhile, according to an embodiment, the user-defined ERP function sharing system may include at least one processor and a memory for storing a program executed by the processor. The processor may include a single core CPU or a multi-core CPU. The memory may include high-speed random access memory and may include non-volatile memory, such as one or more magnetic disk storage devices, flash memory devices, or other non-volatile solid state storage devices, and the like. The memory controller may control access to memory by the processor and other components. Here, the program may cause the user-defined ERP function sharing system according to the present embodiment to perform the user-defined ERP function sharing method when the program is executed by the processor.

Meanwhile, the user-defined ERP function sharing method according to the embodiment of the present invention may be implemented in the form of computer-readable program instructions and stored in a computer-readable recording medium. The computer-readable recording medium includes various recording devices that can store data read by a computer system.

The program instructions recorded on the recording medium may be program instructions specially designed and constructed for the present invention, or may be program instructions known and available to those skilled in the software art.

Examples of the computer readable recording medium include magnetic media (magnetic media) such as hard disks, floppy disks, and magnetic tapes, optical media (optical media) such as compact discs (CD-ROMs), and Digital Video Discs (DVDs), magneto-optical media (magnetic discs) such as optical disks (floptical disks), and hardware devices specifically configured to store and execute program instructions, such as read-only memories (ROMs), random Access Memories (RAMs), flash memories, and the like.

The computer readable recording medium can also be distributed over network coupled computer systems so that the computer readable code is stored and executed in a distributed fashion.

Examples of program instructions include not only machine language code, such as produced by a compiler, but also high-level language code that may be executed by a device, such as a computer, that electronically processes information using an interpreter or the like.

The hardware devices may be configured to operate as one or more software modules to perform the operations of the invention, and vice versa.

It will be understood by those skilled in the art that the foregoing description of the present invention is for illustration only, and that various changes and modifications may be made without departing from the technical spirit or essential characteristics of the present invention as will be readily apparent to those skilled in the art. Accordingly, it should be understood that the above-described embodiments are illustrative in all respects and not restrictive. For example, components described as singular can be implemented in a distributed manner, and components described as distributed can also be implemented in a combined manner.

The scope of the present invention is defined by the following claims rather than the above detailed description, and all changes and modifications that come within the meaning and range of equivalency of the claims are to be understood to be embraced therein.

Industrial applicability

The method and the system can be used for sharing the user-defined ERP function.

Claims

1. A method of sharing user-defined ERP functions, comprising:

a step of receiving, by a user-defined ERP function sharing system, a source package corresponding to a predetermined ERP user-defined function from a plurality of sharer terminals, the source package including at least one SQL file and a design file, wherein the SQL file is a file storing a structured query language query for operating a database, the design file is a file storing at least one control attribute information constituting a screen of the user-defined ERP function, wherein at least a part of controls constituting the screen of the user-defined ERP function is a control mapped to the query included in the at least one SQL file;

a step in which the user-defined ERP function sharing system stores source packages received from a plurality of sharer terminals in a predetermined repository;

Providing a source package list stored in the repository to a user terminal by the user-defined ERP function sharing system; a kind of electronic device with high-pressure air-conditioning system

A step of transmitting a target source packet selected by the user terminal from among source packets stored in the repository to the user terminal in response to a request of the user terminal;

the step of storing source packages received from the plurality of sharer terminals to a predetermined repository by the user-defined ERP function sharing system includes:

a step of determining to which of a predefined plurality of categories a user-defined ERP function corresponding to the source package belongs; and

classifying the source package into a category to which the corresponding user-defined ERP function belongs and storing the source package into the repository;

the user terminal performs a source packet uploading method and a source packet downloading method,

the source packet uploading method comprises the following steps:

a step of providing a source package upload UI providing a function of selecting at least some items from a list of at least one source package stored in the user terminal; and

a step of transmitting a source package corresponding to the selected item to the user-defined ERP function sharing system through the source package upload UI,

The source packet downloading method comprises the following steps:

a step of receiving a source package list stored in the repository from the user-defined ERP function sharing system;

a step of providing a source package download UI that provides a function of selecting at least some items from the received source package list; and

and receiving a source package corresponding to the selected item from the user-defined ERP function sharing system through the source package download UI.

2. The sharing method of user-defined ERP functions of claim 1, wherein,

a step of determining to which of a predefined plurality of categories a user-defined ERP function corresponding to the source bundle belongs, comprising:

analyzing at least one SQL file contained in the source package or a design file contained in the source package; and

and judging which one of a plurality of categories the user-defined ERP function corresponding to the source package belongs to based on the analysis result.

3. The sharing method of user-defined ERP functions of claim 1, wherein,

the user terminal receives the target source package from the user-defined ERP function sharing system, and then executes a user-defined ERP function generation method corresponding to the target source package,

The method for generating the user-defined ERP function corresponding to the target source package comprises the following steps:

a step of providing a container UI including UI objects corresponding to ERD files, which are files for storing modeling information, i.e., attributes about tables and modeling information about relationships between tables stored in a DB, a UI object corresponding to each of at least one SQL file included in the target source package, and a UI object corresponding to a design file included in the target source package;

a step of providing an ERD file editing function for editing the ERD file when a UI object corresponding to the ERD file is selected;

a step of providing an SQL file editing function for editing an SQL file corresponding to the selected UI object when the UI object corresponding to one of the at least one SQL file is selected;

a step of providing a design file editing function for editing the design file when a UI object corresponding to the design file is selected; and

providing the user-defined ERP function based on at least one of the SQL file and the design file.

4. A computer readable storage medium storing a computer program which, when executed by a processor, implements the method recited in any one of claims 1 to 3.

5. A user-defined ERP function sharing system is characterized in that,

as a user-defined ERP function sharing system,

comprising at least one processor;

a memory for storing a computer program for execution by the processor,

wherein the computer program, when executed by the processor, causes the user-defined ERP function sharing system to perform a user-defined ERP function sharing method,

the user-defined ERP function sharing method comprises the following steps:

a step in which the user-defined ERP function sharing system receives source packages corresponding to predetermined ERP user-defined functions, including at least one SQL file and a design file, from a plurality of sharer terminals, wherein the SQL file is a file storing SQL queries for operating a database, the design file is a file storing at least one control attribute information constituting a picture of the user-defined ERP function, wherein at least a part of controls constituting the picture of the user-defined ERP function is a control mapped to queries included in the at least one SQL file;

the source packet uploading method comprises the following steps:

The source packet downloading method comprises the following steps:

6. The sharing system of user-defined ERP functionality of claim 5, wherein,

7. The sharing system of user-defined ERP functionality of claim 6, wherein,

the user terminal receives the target source package from the user-defined ERP function sharing system, and then performs a generation method of user-defined ERP functions corresponding to the target source package,