Overview

Product Positioning

The positioning of this product is to solve several major pain points in the traditional software development process:

• Project: Unclear requirements, heavy tasks, multiple functions, tight development cycles, and high difficulty in project management;

• Benefit: Software developers have high requirements and invest a large number of personnel;

• Standard: The degree of customization is high and difficult to standardize, making it difficult to take over the original project;

• Iteration: Excessive investment in iteration and updates, and long upgrade and maintenance cycles.

   

Product Features

• Low technical requirements: A person with about 1 to 2 years of development experience can replace a technician with 5 years of experience, as long as they have basic software knowledge;

• High development efficiency: Reduce 90% of the code volume, with most functions implemented through automated configuration. If you are an experienced developer, efficiency can be increased by more than 5 times;

• Instant publishing: From configuration to API interface generation, it generally takes less than 2 seconds, and the efficiency of front-end and back-end collaborative development is extremely high;

• High degree of standardization: Refined simple standard rules to achieve complex business operations, meeting the needs of high personnel mobility and rapid iteration and upgrading;

• Bug defects greatly reduced: Through simplification, standardization, and the use of defect detection tools, defects in development are reduced by more than 70%;

• No intrusion: Support integration and integration with various development language framework platforms without affecting the original development framework.

Support Complex Applications

There are many so-called Low-Code or No-Code platforms that are popular on the market now, which can quickly build forms and processes. However, the complexity of actual business systems is masked by the appearance of fast implementation. They can only be used for some simple applications (such as single tables or simple associated applications), and can only target customers with very simple requirements, but cannot meet enterprise level complex applications.

To achieve enterprise level complex applications, the development platform must meet the following requirements:

• Application Implementation: To be able to deploy in actual project environments, without relying on third-party online platforms, localized deployment, and adaptable to various environments.

• Complex Business: Not just simple business, it should be able to support business collaboration, logical operations, multi table operations, transaction processing, and third-party integration.

• Data Structure: The data structure is open rather than closed, supporting custom data structures. The data structure should be decoupled from the platform to facilitate secondary development and data utilization.

• System Integration: Cannot be invasive or exclusive, facilitating seamless integration with other development platforms and traditional development models.

Quick Start

The official version of the product supports databases such as MySql, SqlServer, Sqlite, etc.

The product includes three catalogs:

• Server side web system

• Client Tools

• Database files

Runtime Environment

Server: Windows OS, Linux, Unix, dotnet sdk 6.0 or above.

Client: Windows OS, dotnet framework 4.8 or above.

Start Web System

Run FTFrame.Web.exe program,The default port is 81,If you want to change the port, you can run it on the command line, for example, to replace it with port 88 :

dotnet FTFrame.Web.dll --urls http://0.0.0.0:88

The screen after startup is as follows:

Access in browser after startup http://localhost:81/ ,the following interface appears:

Enter your account and password (default account is user, password is 123), click the login button to enter the online document management page:

Run Client

Open the FTDP. exe program in the client tool directory, and the demo1 site has been opened by default.

Generate Single Table Application

Click on the right-click menu in the workspace New Page:

Click Build Single Table Components ,Pop up the form for selecting a data table:

Select a data table, for example tb_client :

Click OK,it will generate a file containing Data List,Data Add,Data Modify,Data Query series components and default configuration.

By using the shortcut key Ctrl+Q, the page can be published to the server. The publishing process takes about 1 second to complete. Once we access the server address, we will see the four newly generated interfaces.

Front-end Component Generation

The generated Api interface can be directly called by the front-end, and this product also provides the function of directly generating Vue front-end components and front-end pages based on the interface.

Right click in the component area of the page editing and select from the menu Go To Front-end ,can quickly generate front-end components.

What is selected here is Data List component,now click Import From Api, can automatically complete the docking of the front and back ends:

Select Live Preview ,We can call the embedded browser to view the configuration effect of the front-end components in real-time:

For more functions on generating front-end components and front-end pages, please refer to the relevant documentation on front-end development.

Document & Testing

By accessing the server address through a browser, you can view and test the API documentation. Click on Column Custom to select more columns (such as input and output message formats). Click on the Net or Java link to import the API into PostMan for running and testing.

The generated front-end components can be viewed and downloaded online from the front-end component list for their effects:

Site Management

The prerequisite for development is to have a site and have completed the main configuration, which includes server configuration and database configuration.

The demo version has already added demo1 site by default, and its configuration matches the demo server.

Add & Register

You can add sites through Add Site and Register Site. The difference between the two is that Add Site can be added without matching the server first. When Register Site, it is necessary to verify whether the server matches before adding it.

You can add and register sites through the main menu or site management.

When collaborating with multiple developers, registered sites can be quickly registered by exporting configurations and then importing configurations.

Open Site

Two ways to open a site:

1: Menu File ->Open Site, double-click the site you want to open.

2: Set default site in menu tools ->options, so that when opening the client tool, the site will be opened by default.

Site Export & Import

Menu Site ->Export Site, export all files and configurations of the current site to a local file.

Menu Site ->Import Site, import local site files into the current site.

Site Synchronization

When collaborating with multiple developers, the latest files and configurations on the server can be synchronized locally.

Version Management

Site version management is the version management of the entire site, where version generation can be done according to:

• Latest generated version

• Historical snapshot version: Select a point in time where all files closest to and before that point in time form a version

The operation of the version includes: viewing details, rolling back to the current site, downloading or exporting the version site.

Site Publish

Site publishing refers to publishing the specified files of the current site to the server, including several types: full publishing, specified publishing, and quick publishing.

Suggest using a quick publishing method to publish the current individual page. There are three ways to quickly publish:

• Ctrl+Q shortcut key, quickly publish the currently being edited page；

• Select the page in the workspace, right-click on the menu, and select publish the page；

• Menu Tools ->Quickly publish the current activation page.

Site Property Configuration

Select the root node in the workspace and configure the site properties in the attribute area.

The main configuration instructions for attributes are as follows:

Site Structure

Perform basic operations on site directory structure and pages in the workspace.

Directory Management

In the workspace, right-click menu ->New Directory

When creating a new directory, you can perform directory copying operations. The directory copying function is to regenerate instances of all subdirectories, pages, and components under the specified directory and then copy them to the new directory.

Click on the directory to be copied:

To change the directory display name, you can make modifications in the properties section:

Page Definition

A page is an editing unit that has two output modes::

• Traditional page output mode: output HTML code, and components nested within the page generate dynamic HTML according to their positions, which can be directly accessed by browsers；

• JSON output mode: output JSON code. Components nested in the page will output JSON code based on the page URL parameters, which is used to implement the API interface.

  The default output method is JSON. To change the page output type, modify it through the output method of the page properties:

  

New Page

In the workspace, right-click menu ->New Page:

In the actual development process, if the functionality of this page is very similar to that of another, it is often copied. If you want to copy another page, you can choose it by browsing:

When creating a new page, you can quickly build a single table series of components and pop up a data table selection interface:

Select a data table, for example tb_client :

Click OK,it will generate a file containing Data List,Data Add,Data Modify,Data Query series components and default configuration.

After generating the basic components, adjustments and modifications can be made according to business needs.

Page Export & Import

In collaborative development or multiple project development, there is often a situation where the feature I want to do is similar to another project, or if this feature needs to be referenced and copied by other developers, the export and import functions of the specified page can be used.

In the workspace, select the page, right-click on the menu ->Export the page for export, use the menu tools ->Import a single page and then import it again.

Open Page

In the workspace, double-click the page with the mouse to open it, or right-click the menu to open the page.

Backup Management

Every release of the page will be automatically backed up on the server.

In the workspace, select the page, right-click on the menu ->Historical Backup for backup management. You can view all historical backups, select them, and roll them back, or download and export them.

Page Publish

Page publishing is the process of publishing the content and configuration of a page to the server for operations such as API generation, document generation, version generation, and source file generation for NetCore and Java.

Page publishing adopts a fast publishing method, publishing the current single page. There are three ways to quickly publish:

• Ctrl+Q shortcut key, quickly publish the currently being edited page；

• Select the page in the workspace, right-click on the menu, and select publish the page；

• Menu Tools ->Quickly publish the current activation page.

  Under normal circumstances, the publishing time is around 1 to 3 seconds.

Page Editing

After opening the page, enter the page visualization editing environment, which supports regular HTML visualization WYSIWYG editing. The editing window is divided into three parts: design area, code area, and preview area, which include regular HTML editing functions. Select HTML elements and make attribute modifications in the attribute area.

Page Right-Click Menu

The right-click menu on the page is divided into component functions, page editing functions, and auxiliary functions. This chapter will first only introduce auxiliary functions.

Option Setting

Menu Tools ->Options, set global client settings.

System Setting

The settings related to display classes are not listed one by one, mainly the following items:

Server Database Config

Component Usage

The use of components is the core of this product, and based on refinement, we have found that conventional business functions can be decomposed into the following three or a combination or nesting of these three:

• Data List: Multiple pieces of data with the same structure, such as lists, dictionaries, options, etc., and batch operations on multiple pieces of data

• Data Operation: The combination operation of adding, modifying, or adding and modifying a certain piece of data

• Data Getting: Obtain the content of a certain piece of data

In actual business scenarios, we need to combine and nest these three types, and there will be certain logical judgments. However, more than 80% of business scenarios cannot do without these three types.

So by mastering these three types of component configurations, almost 80% of the development content of regular business systems has been completed.

Add New Component to Page

There are three ways to add new components:

1: Right click in the editing area to insert a component:

2: Left toolbar ->Standard components, drag and drop components to the editing area:

3: Workplace components, drag component instances to the editing area:

Generate from Existing Component

In actual development scenarios, the features we want to add are partially similar to those that have already been developed, and we can use replication or cloning methods.

1: Select the component on the page you want to copy, use Ctrl+C or right-click to copy, and use Ctrl+V or right-click to paste it into the editable area of the new page；

2: Clone and Replace: Copy all configurations of the component, regenerate the component instance, and replace the original in the editing area；

3: Clone and Append: Copy all configurations of the component, regenerate the component instance, and append a new component below the original component；

4: Clone: Copy all configurations of the component, regenerate the component instance, and the new component will only appear in the component area of the workspace.

Property Setting

Select a component in any way to edit its configuration in the attribute area.

To meet different application scenarios, components can be selected in all three regions:

• Left toolbar ->Page shortcut operation area, select the component

• Visual area selection component in the page editing area

• Select components in the tree structure of the workspace (under page node)

  

Define Quick Properties

In order to meet the needs of different scenarios, the number of component attributes will be greater than the configuration requirements required for our specific project, and the attention and importance of these configuration items in our actual business scenarios will also vary.

We can now customize the display and sorting of component properties. After selecting a component, the property area displays all the configurable properties of the component. In the right-click menu ->Component Shortcut Property in the editing area, only the few property configurations that we are interested in will be displayed.

Click Setting to customize the shortcut properties and sorting of all components:

Data List

Only introduce the attribute configuration instructions closely related to Api interface generation.

Main Properties

Data Rule Configuration

Double click on the selected component at any location, or click on property configuration or shortcut property configuration to configure data rules.

Defined column display names, comments (to be displayed in the generated Api document), data definitions, etc.

If the basic data source has already been defined (with main table identification or fully customized queries configured), columns can be quickly defined from the data structure through Quick Define , such as:

Rules for defining data:

Api Configuration

Api Define Quickly Configure Api Interface through Data Rule Configuration.

• Hidden parameters isExport, exportMax, and exportName represent the input parameters when exporting to Excel

• Custom export file names can override the system's default timestamp generated file names during export

• There are two types of input methods: JSON input or form input, usually JSON input

• Please refer to the description of each field for detailed instructions on entering parameters

Api Document

After quick publish, browse the Api document online. The example of the Data List document is as follows:

Data Operation

Only introduce the attribute configuration instructions closely related to Api interface generation.

Main Properties

Data Rule Configuration

Double click on the selected component at any location, or click on property configuration or shortcut property configuration to configure data rules.

Name

Name or annotation, application scenario is:

• Prompt text given when validation is configured and the field validation fails

• Comment for this field in the Api document

ID/Key

The field for Api input must be unique.

Binding

Bind database tables and fields. When the row is configured with subtable operations, only bind the data subtable. Double click for quick configuration.

Type

Main types of explanations:

Validation

Quick settings for validation rules, more complex validation rules are set in the premise of operating the main attributes.

Filter Rule

Generally used for querying or updating. A、 Filter data using column name=value (default to primary key column as filter column)

1. Definition of primary key column (1) , default to the primary key column name rule configured in the Project project; (2) The component parameter "primary key column name" can overwrite or redefine all configured filtering column names of the component; (3) Each item in the data rule configuration can override the above definition again. When overriding the filter column definition, the filter value must also be defined, such as @p1@, idCustom, which means the filter rule is idCustom='@p1@'.

2. Definition of value (1) , default to using the first sequence parameter as the filtering value, i.e. @p1@; (2) The default primary key value of the component parameter can override or redefine the filtering values for all configurations of the component; (3) Each item defined by the rule can once again override the above definition, such as @p2@, or for example @key(idCustom);

B、 Custom filtering criteria

1. "where" starting string, for example, where name='@key(user)' and area='@p1@'.

C、 Built in syntax supported by configuration items:

1. Sequence parameters @p[n]@, such as @p1@, @p2@;

2. @key ([name]), obtained from input parameters, such as @key(username);

3. @code ([define]), obtained from the defined backend method;

4. @enum([define]), obtained from the enumeration defined by the site parameters;

5. @dic([define]), obtained from the dictionary table defined by the server;

6. @para{[define]}, obtained from the site parameter definition;

7. @from([@table. col]), obtain the final value from other fields.

Advanced

A、 Configuration rules

1. If it is not empty, the default return is the filled string, ignoring the input parameters;

2. When configured as @sql: starting string, return the SQL query value (first row, first column);

B、 Built in syntax supported by configuration items:

1. Sequence parameters @p[n]@, such as @p1@, @p2@;

2. @key([name]), obtained from input parameters, such as @key(username);

3. @code([define]), obtained from the defined backend method;

4. @enum([define]), obtained from the enumeration defined by the site parameters;

5. @dic([define]), obtained from the dictionary table defined by the server;

6. @para{[define]}, obtained from the site parameter definition;

7. @from([@ table. col]), obtained from the final values of other fields;

8. Other: @empty@ "empty string" value, @newfid@ primary key value when adding.

When configuring sub table operations to reset or update, advanced columns need to be configured with filtering conditions.

Quick Define

Configuration can be quickly completed from data structures through Quick Define , such as:

Quickly select and configure the data table after selecting it:

• Select All: Select all fields in the table；

• Select All (ignoring primary key columns, retaining columns): Select all columns except for primary key columns and retaining columns.

  Note
  

  The primary key column and reserved column are defined by rules in the Project project.

Sub Table Configuration

Data Operation, operations can be performed on its child tables simultaneously. The example configuration is as follows:

Double click on the name or key column to configure sub table details:

Sub table details can also be configured through Quick Define:

The results after configuration are as follows:

The types in the subtable details are generally default. If you need to configure the subtable in the next layer, you can continue to select subtable configuration in the subtable details. The rules are the same as above.

According to the previous relationship between the parent-child table, the child table can be configured with special values, including the following types:

• Primary Key Value of sub table (If the primary key rule for this sub table is defined in the Project project, it is generally not necessary to configure this item)

• Primary Key Value of parent table (The primary key value of the associated parent table. If the parent table is newly added, the primary key value of the new record in the parent table will be automatically associated)

• Same Name Value of parent table (For special application scenarios, obtain field values with the same field names in the parent table based on the bound field names)

Api Configuration

By configuring data rules through Api Define, Api interfaces can be quickly configured, and input parameter fields can be adjusted and mapped again.

• There are two ways to input parameters: Json or Form, usually Json.

• Please refer to the description of each field for detailed instructions on entering parameters.

   

Api Document

After quick publish, browse the Api documentation online. An example of the Data Operation documentation is as follows:

Data Getting

Only introduce the attribute configuration instructions closely related to Api interface generation.

Main Properties

Data Rule Configuration

Double click on the selected component at any location, or click on property configuration or shortcut property configuration to configure data rules.

Name

Name or annotation, application scenario: annotation for this field in Api document.

ID/Key

The field for Api output must be unique.

Binding

Bind database tables and fields.

Filter Rule

Generally used for querying or updating. A、 Filter data using column name=value (default to primary key column as filter column)

1. Definition of primary key column (1) , default to the primary key column name rule configured in the Project project; (2) The component parameter "primary key column name" can overwrite or redefine all configured filtering column names of the component; (3) Each item in the data rule configuration can override the above definition again. When overriding the filter column definition, the filter value must also be defined, such as @p1@, idCustom, which means the filter rule is idCustom='@p1@'.

2. Definition of value (1) , default to using the first sequence parameter as the filtering value, i.e. @p1@; (2) The default primary key value of the component parameter can override or redefine the filtering values for all configurations of the component; (3) Each item defined by the rule can once again override the above definition, such as @p2@, or for example @key(idCustom);

B、 Custom filtering criteria

1. "where" starting string, for example, where name='@key(user)' and area='@p1@'.

C、 Built in syntax supported by configuration items:

1. Sequence parameters @p[n]@, such as @p1@, @p2@;

2. @key ([name]), obtained from input parameters, such as @key(username);

3. @code ([define]), obtained from the defined backend method;

4. @enum([define]), obtained from the enumeration defined by the site parameters;

5. @dic([define]), obtained from the dictionary table defined by the server;

6. @para{[define]}, obtained from the site parameter definition;

7. @from([@table. col]), obtain the final value from other fields.

.

Getting Type

• Single Row: When outputting Json, this line returns a value；

• Multiple Rows: When outputting Json, this line returns an array.

Advanced

A、 Configuration rules

1. If it is not empty, it is recognized as SQL by default. The query result is output based on SQL. If Multiple Rows are configured, it is output as an array object. Otherwise, the first row and first column values of the SQL query result are returned;

2. When configured as @code, return the value of the back-end method;

3. When configured as sql@code Then return the value of the back-end method as SQL and query it again;

4. When configured as str@code Then return the value of the original field and call the back-end method with @val@ as the parameter;

5. When configured as @api_, return the JSON that calls the interface;

6. When configured as @sql:, it is the same as 1.

B、Built in syntax supported by configuration items:

1. Sequence parameters @p[n]@, such as @p1@, @p2@;

2. @key([name]), obtained from the parameter to be output, such as @key(username);

3. @code([define]), obtained from the defined back-end method;

4. @enum([define]), obtained from the enumeration defined by the site parameters;

5. @ dic([define]), obtained from the dictionary table defined by the server;

6. @para{[define]}, obtained from the site parameter definition;；

Quick Define

Configuration can be quickly completed from data structures through Quick Define, such as:

Quickly select and configure the data table after selecting it:

• Select All: Select all fields in the table；

• Select All (ignoring primary key columns, retaining columns): Select all columns except for primary key columns and retaining columns.

  Note
  

  The primary key column and reserved column are defined by the Project project

   

Api Configuration

By configuring data rules through Api Define, Api interfaces can be quickly configured, and parameter fields can be adjusted and mapped again.

Api Document

After quick publish, browse the Api documentation online. An example of the Data Getting documentation is as follows:

Built-in Syntax

Not all syntax supports all configurations, please refer to the property setting instructions for details.

@code

Function: Calling server-side program methods (requires compilation)

Defined in the Project project or by reflecting remote methods.

The syntax is @code(define,para1|para2|...),define is the identifier, and multiple parameters are separated by |.

@para

Function: Calling basic methods with logical processing and returning a string (No compilation required)

Defined by the site parameter tool. Please refer to the section on practical Tool ->Site Parameters for details.

The syntax is @para{define,para1|para2|...},define is the identifier, and multiple parameters are separated by |.

@key

Function: Obtaining the values of input and output parameters during Data Operation and Data Getting

The syntax is @key(keyName).

@sql:

Function: Define a SQL statement

@api_

Function: Define an existing Api interface for nested calls or execution

The syntax is @api_/somePage?list/[colname]/@p[n]@.

@p[n]@

Function: Sequence parameters used to obtain the specified position when calling the Api interface

For example, when calling an Api interface, the URL is somePage?list/a/b/c,then @p1@ is a,@p2@ is b,@p3@ is c, Supports up to 12 sequence parameters.

@from

Function: Obtain the final value based on the bound field during Data Operation, and obtain the output value of parameter during Data Getting

The syntax is @from(tableName.column),@from(keyName).

@enum

Function: The corresponding conversion between values and display text, similar to enumeration

Defined by the Site Parameter tool (starting with Enum_).

The syntax is @enum(key.item),Key is the identifier, item is the item.

Practical Tools

This product integrates a large number of innovative and practical tools.

Site Parameter

In configuration oriented project development, we will face such problems:

• There is a significant amount of duplication in configuration items

• Some configurations are not written to death and require dynamic changes based on certain conditions

• There are several types of configurations that are very similar, and I want to write them as one configuration

• To achieve some unified management of complex configurations

• How to rely on and nest between configurations

• The combination of several configurations forms a configuration and is managed uniformly

Therefore, we have designed and developed a Site Parameter tool to unify the management of complex, commonly used, and logical configurations. Our built-in syntax can still be used in these configurations, and these configurations can be used in all supported attribute configurations of the entire site.

Menu click on Tool->Site Parameter:

In the configuration, @para[n]@ is used to represent the input parameters when calling the site parameters. For example, if the calling method is @para{define, @key(name)|9}, then @para1@ is the value of @key(name), and @para2@ is 9.

In the following typical examples, we return different SQL query statements based on the different parameters of the input parameters:

Or a simple SQL concatenation condition:

You can also have the site parameters execute Sql or execute a Data Operations API, with multiple executions separated by ##, for example, performing different operations based on different conditions:

Bug Detection

After establishing standardized configuration rules, we can easily detect some errors and defects in the configuration by setting detection rules.

Menu click on Tool->Bug Detection:

Optional detection range: current page, custom detection page, full site detection.

The detection types include: Api configuration detection, front-end configuration detection, and rule design detection.

After clicking the start button, the detection results will be quickly displayed as follows:

Defined the type, location, description, and level of defects.

Search in Configuration

When there are a large number of configurations, the problem that needs to be solved when adjusting one or a large number of similar configuration items is:

• Need to quickly locate a configuration item, rather than opening the location step by step through directories, pages, component properties, etc；

• When batch changing a certain type of configuration item, it can be uniformly modified and confirmed without displaying unnecessary configuration items；

• After quickly modifying configuration items, updates can be directly published to the server without the need to navigate to the page and publish again.

  Menu Tool ->Search in Configuration. We enter the search content and through a full site search, it can help us locate specific configuration items in bulk.

Export Database Structure

Menu Tool ->Export Database Structure, can export the server-side database structure as an Excel document.

Rule Design

This feature is an exploratory feature that mainly allows business rules to constrain configuration. In bug detection, this rule design will be called to detect some business-related defects.

Separate Publish

During page development, HTML editing is done by third-party tools, and this product only does component configuration.

In the Api development scenario, this feature has been deprecated.

Front-end Development

Quickly configure front-end components through standardized Api interfaces, and then export front-end pages through front-end page templates.

The front-end development of this product is currently based on the Vue framework, with the UI framework being ElementUI.

Front-end Component

Click on the menu Tool ->Front-end Component Generate to open the Front-end Component Generate Tool.

General Introduction

There are several types of front-end components:

• List component (corresponding to Data List in Api interface type)

• Form component (corresponding to Data Operation and Data Getting in Api interface types)

The left column displays the tree structure of all front-end components. When exporting front-end components, they will be exported according to the hierarchical relationship of the tree structure.

The server-side browsing front-end components are as follows:

The right-click menu in the left column is as follows:

When the front-end components are released, the server will automatically back up. When collaborating with multiple developers, view and download the backup list of the specified components:

Or click Update All to obtain the latest all front-end components on the server.

Generate Page Function: Select a directory that may contain multiple front-end components. Clicking on the page generation function will automatically match the front-end page template and generate front-end pages according to the rules of the page template for the series of front-end components.

Preview Function: Call the browser to preview the effect of local front-end components.

Export Function: Export selected front-end components to local.

Configuration Features: Configure Api call address and related settings:

List Component

Basic Information

• Component names with slashes/ indicate directory structure

• Specify the Api interface for the Data List, which can be selected through buttons

• Click the configuration button to directly go to the page where the interface is located for interface configuration

  

Columns Configuration

After defining the list interface, it is easy to automatically dock fields by clicking Import From Api, and fields that do not match the Api interface fields will also be marked in red font.

After selecting Live Preview, call the embedded browser to preview the configuration effect in real time:

Description of each configuration item:

Search Configuration

Define search criteria for the search bar, input methods include text boxes, dropdown selections, dates, date ranges, and custom templates.

The bound field refers to the interface field bound to the search condition, which can be selected by double clicking:

Placeholders are the default displayed prompt text.

Support custom settings for styles.

Initialize template:

The initialization content is a combination of statically defined content and content obtained from the interface. For example, we have defined male and female dropdown options as initialization data:

Buttons Configuration

Configure button types, text, icons, appearance, grouping, and other settings.

Event Setting: Define the click event for this button, select and configure it after clicking.

Built in events include: query, reset, batch operation, export, and customization.

Script Definition

Script definitions include initialization, before loading, before setting, after setting, customization, and styling.

Other Definition

Form Component

Basic Information

• Component names with slashes/ indicate directory structure

• Specify the Api interface for Data Getting, which can be selected through a button

• Specify the Api interface for Data Operation, which can be selected through buttons

• Click the configuration button to directly go to the page where the interface is located for interface configuration

  Important
  

  In general:

  When adding: Do not configure Data Getting, configure Data Operation

  When modifying: configure Data Getting and Data Operation

  When viewing: Configure Data Getting, do not configure Data Operation

   

Rows Configuration

After defining the interface, it is easy to automatically dock fields by clicking Import From Api. You can choose to import from Data Getting or Data Operation, and fields that do not match the Api interface fields will also be marked in red font.

After selecting Live Preview, call the embedded browser to preview the configuration effect in real time:

Description of each configuration item:

Item	Description
Display	Display text for form items
Bind	Bind Api interface key
Type	It contains more than ten types, and the most special one is the built-in Integration Template type, which is configured by site parameters
Placeholder	Displayed prompt text
Style	Define styles
Initializate	The initialization content is a combination of statically defined content and content obtained from the interface. For example, we have defined male and female dropdown options as initialization data:
Template/Property	Define attributes or define content through template templates, supporting @para syntax
Validation	Choose built-in validation rules or custom validation rules
Layout	Customize the layout and set the number of form items displayed in each row

Integration Template

The last type of form item is the integration template, which is defined by site parameters. In actual business scenarios, form items are composed of a large number of front-end code combinations, and even have coupling relationships with the data of other form items, such as cascading selection, file processing, image upload and display, rich text editing, and the combination of multiple form items.

Commonly used integration templates have been configured through site parameters, such as:

When using, simply select the integration template type, then select the corresponding integration template and configure the input parameters to achieve complex front-end scenarios:

Buttons Configuration

Configure button types, text, icons, appearance, grouping, and other settings.

Event Setting: Define the click event for this button, select and configure it after clicking.

Built in events include: submit, reset, and customize.

Script for Getting

It is recommended to use the default configuration, which is automatically generated when exporting components and matches automatically based on the interface type.

Script for Operation

It is recommended to use the default configuration, which is automatically generated when exporting components and matches automatically based on the interface type.

Script Definition

The script definition includes initialization, before getting, before setting, after setting, before submitting, after submitting, customization, attaching data objects and styles.

Other Definition

Front-end Page

Template Configuration

Click on the menu Tool ->Front-end Page Generate to open the Front-end Page Template Configuration Tool.

Configure the template code and the component types related to the template. After saving, the page can be generated in the front-end component development tool.

Template Usage

Select the directory of the component tree structure of the front-end component generation tool, right-click to select the generation page, select the template to be applied, and then generate the front-end page for the series of front-end components according to the rules of the page template.

Client Other

Text Editor

Most text configurations will be completed within the text editor.

The text editor supports automatic completion and click prompts, with completion types including SQL syntax, data tables, data table fields, and various built-in syntax.

Quick definitions include:

Site Parameter

Common Configurations:

Assembly Calls

Can directly select public methods for server-side programs:

When collaborating with multiple people, server methods defined by other developers can be synchronized.

The configuration returned by assembly method calls is @code syntax, and the methods defined in the Project project are regular calls.

If other custom methods are configured with dynamic compilation on the server, they are called normally. Otherwise, the method is called through reflection.

Script Calls

Api Calls

Select published Api interfaces for calling.

SQL Editor

Most SQL configurations will be completed within the SQL editor.

The SQL editor supports automatic completion and click prompts, with completion types including SQL syntax, data tables, data table fields, and various built-in syntax.

Sql templates can be defined in the abstract fragment in advance, and can be quickly selected in the SQL editor.

The edited SQL query statement can be tested and data previewed by clicking the test button.

Snippets

The summary column on the left toolbar defines snippets for quick input.

The commonly used [SQL] starts with SQL statement templates, and [Front] starts with front-end templates.

Site Template

Classify and manage sites for specific business scenarios.

Check and Update Product

Check if the client tool is updatable, download and restart the client tool to complete the update operation.

Multilingual Switch

International applications.

Currently supports both English and Chinese, with an increasing number of languages as needed.

Server Project

The server project is .Net Core Web Project

Server Startup

Run FTFrame.Web.exe program,The default port is 81,If you want to change the port, you can run it on the command line, for example, to replace it with port 88:

dotnet FTFrame.Web.dll --urls http://0.0.0.0:88

The screen after startup is as follows:

Access in browser after startup http://localhost:81/ The following interface appears:

Configuration File

The configuration files are located in the appsettings.json and job.json directory at the root of the web project. After making changes, the web service needs to be restarted.

Main Configuration

appsettings.json :

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "DataBase": {
    "DataBaseType": "Sqlite", // Database type,for example:MySql , SqlServer , Sqlite
    "ConnectionStr": "Data Source=../db/test.db;",
    "ConnectionStr_ReadOnly": "", // If it is empty, then the same as ConnectionStr
    "ConnectionStr_FTDP": "Data Source=../db/test_plat.db;", // Just for FTDP Server Required Tables, If it is empty, then the same as ConnectionStr
    "ModelDllName": "FTFrame.Project.Model"
  },
  "LogLevel": "2",
  //"Jwt": {
  //  "SecretKey": "",
  //  "ExpiresMinutes": "30",
  //  "Domin": "http://localhost"
  //},
  "Site": {
    "LogPath": "../ftsite_log",
    "SystemName": "FTDP Server",
    "SystemTitle": "FTDP Site",
    "CodeGetCompile": "false",
    "SettingEncode": "false",
    "SubPath": "",
    "HostReferrer": "",
    "RoutePathReplace": "",
    "OriginAllowed": "*"
  },
  // Generate Java files simultaneously when generating net core files,if the setting of RootPath is empty,then ignore
  "Java": {
    "RootPath": "../ftsite_java", // The path generated by Java source files
    "JarName": "FTFrameWeb-0.0.1-SNAPSHOT.jar", // The name of the generated jar package
    "BaseUrl": "http://localhost:9330", // java web site address
    "Port": "9330", // java web site port
    "JAVA_HOME": "/home/ubuntu/jdk1.8.0_341",
    "MAVEN_HOME": "" // If empty, will not dynamically compile and deploy, only generate source files
  },
  "Publish": {
    "SiteBak": "../ftsite_bak",
    "IsApiCompile": "false",
    "DllCompilePath": "",
    "RegisterNumber": "",
    "RegisterSiteKey": "MyCustomCDKey" // Must be same with FTDP Client CDKey,otherwise the client can not publish to this site
  }
}

Job Configuration

job.json : Configure scheduled tasks, task execution types include WebApi (calling Api interface) and Function (calling assembly methods)

xxxxxxxxxx
[
  {
    "interval": "hour", //hour,day,month
    "trigger": "18:10", //
    "job": [
      /* {
        "type": "WebApi",
        "value": "http://aaa"
      },
      {
        "type": "Function",
        "value": "FTFrame.BLL,FTFrame.BLL.Busi,Cacu_Index"
      }*/
    ]
  },
  {
    "interval": "day",
    "trigger": "01:00:00",
    "job": [
      /*{
        "type": "Function",
        "value": "FTFrame.BLL,FTFrame.BLL.Busi,Cacu_Index"
      }*/
    ]
  }
]

Project Project

This project is the core of server configuration, and the main configuration items are introduced here.

Usage

After compiling the project, replace FTFrame.Project.Core.dll file, then restart the server service.

DBSuit

• Can redefine database types and connections

• Configuration logic for read-only databases

• Configuration rules for primary keys (generation rules for primary key columns and primary key values)

• Preprocessing of data field output

• Rules for retaining columns when adding new data

• Preserve column rules when modifying data

  xxxxxxxxxx
  /// <summary>
      /// Based on the actual situation of database design, define the logic for obtaining primary keys, retaining fields, and storing them
      /// </summary>
      public static class DBSuit
      {
          /// <summary>
          /// Obtain a read-only database connection string, and define rules when there are multiple read-only databases.
          /// If 'Data List' or 'Data Getting' with data operations (as Batch updates,Execute after getting) cannot be used as read-only
          /// </summary>
          /// <returns></returns>
          public static (DBClient.DataBase DataBaseType, string ConnString) ReadOnlyConnection(HttpContext context)
          {
              // Multiple read-only databases can be specified according to rules
              // Connection strings can be obtained from the configuration file, for example:ConfigHelper.GetConfigValue("Project:ConnString_V1")
              return (DBConst.DataBaseType,SysConst.ConnString_ReadOnly);
          }
          /// <summary>
          /// Obtain the basic database connection string (read-write) and define rules
          /// </summary>
          /// <param name="context"></param>
          /// <returns></returns>
          public static (DBClient.DataBase DataBaseType, string ConnString) BaseConnection(HttpContext context)
          {
              return (DBConst.DataBaseType, SysConst.ConnString);
          }
          /// <summary>
          /// Important:Rules for defining primary key values
          /// </summary>
          /// <param name="tableName"></param>
          /// <param name="fidCol"></param>
          /// <returns></returns>
          public static (string KeyName, Enums.KeyType KeyType) Key(string tableName, string fidCol = null)
          {
              switch (tableName.ToLower())
              {
                  case string r when (r.StartsWith("cn_") || r.StartsWith("ef_")):
                      return ("id", Enums.KeyType.AutoIncrement);
                  case string r when (r == "ft_test_table"):
                      return ("fid", Enums.KeyType.Guid);
                  default:
                      if (string.IsNullOrEmpty(fidCol)) return ("id", Enums.KeyType.SnowId);
                      else return (fidCol, Enums.KeyType.Guid);
              }
          }
          /// <summary>
          /// If no data table name specified, infer primary key columns and types
          /// Only in data list show
          /// </summary>
          /// <param name="dr"></param>
          /// <param name="mainTable"></param>
          /// <returns></returns>
          public static (string KeyName, Enums.KeyType KeyType) Key(this DR dr, string mainTable = null)
          {
              (string KeyName, Enums.KeyType KeyType) key = (null, Enums.KeyType.Guid);
              if (mainTable != null) key = Key(mainTable);
              if (key.KeyName != null && key.KeyName != "NullKey" && dr.FieldIndex(key.KeyName) >= 0) return key;
              //other
              return dr.GetDataTypeName(0) == "bigint" ? (dr.GetName(1), Enums.KeyType.Guid) : (dr.GetName(0), Enums.KeyType.Guid);
          }
          /// <summary>
          /// Primary key value generation rules
          /// </summary>
          /// <param name="tableName"></param>
          /// <returns></returns>
          public static object KeyGenerate(string tableName)
          {
              var key = Key(tableName);
              if (key.KeyType == Enums.KeyType.SnowId) return Utils.Str.SnowId();
              if (key.KeyType == Enums.KeyType.Guid) return str.GetCombID();
              return "NullKeyValue";
          }
          /// <summary>
          /// Preprocessing for obtaining output values of database field types
          /// </summary>
          /// <param name="dr"></param>
          /// <param name="colName"></param>
          /// <param name="tableName"></param>
          /// <returns></returns>
          public static (string val, bool quotation) CommonValue(this DR dr, string colName, string tableName = null, int? colOrdinal = null)
          {
              var val = dr.GetValue(colOrdinal ?? dr.GetOrdinal(colName));//IsDBNull?
              if (val == null) return ("", true);
              switch (val.GetType().Name.ToLower())
              {
                  case "date":
                      return (str.GetDate((DateTime)val), true);
                  case "datetime":
                      return (str.GetDateTime((DateTime)val), true);
                  case "int":
                  case "int32":
                  case "decimal":
                  case "double":
                  case "float":
                  case "single":
                  case "int16":
                  case "int64":
                  case "byte":
                  case "sbyte":
                  case "bool":
                  case "long":
                  case "ulong":
                  case "short":
                  case "ushort":
                  case "uint":
                      return (val.ToString(), false);
                  default:
                      return (val.ToString(), true);
              }
          }
          /// <summary>
          /// Default fields and value definitions when adding data to the interface
          /// </summary>
          /// <param name="tableName"></param>
          /// <returns></returns>
          public static Dictionary<string, object> DefaultColsWhenAddForApi(string tableName, Dictionary<string, object> reqDic)
          {
              var dic = new Dictionary<string, object>();
              tableName = tableName.ToLower();
              try
              {
                  if(tableName.StartsWith("tb_"))
                  {
                      dic.Add("_add_time", str.GetDateTime());
                      dic.Add("_add_user", User.UserID(reqDic));
                      dic.Add("_update_time", str.GetDateTime());
                      dic.Add("_update_user", User.UserID(reqDic));
                      dic.Add("_available_flag", 1);
                  }
                  else if (tableName.StartsWith("cn_") || tableName.StartsWith("ef_"))
                  {
                      dic.Add("create_time", str.GetDateTime());
                      dic.Add("create_by", User.UserID(reqDic));
                      dic.Add("update_time", str.GetDateTime());
                      dic.Add("update_by", User.UserID(reqDic));
                      dic.Add("is_delete_flag", 1);
                  }
              }
              catch (Exception ex)
              {
                  log.Error(ex);
              }
              return dic;
          }
          /// <summary>
          /// Default fields and value definitions when modifying data through interfaces
          /// </summary>
          /// <param name="tableName"></param>
          /// <returns></returns>
          public static Dictionary<string, object> DefaultColsWhenModForApi(string tableName, Dictionary<string, object> reqDic)
          {
              var dic = new Dictionary<string, object>();
              tableName = tableName.ToLower();
              try
              {
                  if (tableName.StartsWith("tb_"))
                  {
                      dic.Add("_update_time", str.GetDateTime());
                      dic.Add("_update_user", User.UserID(reqDic));
                  }
                  else if (tableName.StartsWith("cn_") || tableName.StartsWith("ef_"))
                  {
                      dic.Add("update_time", str.GetDateTime());
                      dic.Add("update_by", User.UserID(reqDic));
                  }
              }
              catch (Exception ex)
              {
                  log.Error(ex);
              }
              return dic;
          }
          /// <summary>
          /// Default fields and value definitions when adding data to a page
          /// </summary>
          /// <param name="tableName"></param>
          /// <returns></returns>
          public static Dictionary<string, object> DefaultColsWhenAddForPage(string tableName)
          {
              return DefaultColsWhenAddForApi(tableName,null);
          }
          /// <summary>
          /// Default fields and value definitions when modifying data on a page
          /// </summary>
          /// <param name="tableName"></param>
          /// <returns></returns>
          public static Dictionary<string, object> DefaultColsWhenModForPage(string tableName)
          {
              return DefaultColsWhenModForApi(tableName, null);
          }
      }
  

Api

• Define the authorization logic for Api

• Define the output structure of Api

  xxxxxxxxxx
  public class Api
      {
          /// <summary>
          /// Api authorization
          /// </summary>
          /// <param name="businessType">List,DyValue,DataOP</param>
          /// <param name="path">Api Path</param>
          /// <param name="paras">Sequence Parameters</param>
          /// <param name="context">HttpContext</param>
          /// <param name="reqDic"></param>
          /// <returns></returns>
          public static bool Auth(string businessType, string path, string[] paras, HttpContext context, Dictionary<string, object> reqDic = null)
          {
              //if (!User.IsLogin()) return false;
              string key = paras[0];
              return true;
          }
          public static string AuthFailedJson(string businessType, string path, string[] paras, HttpContext context)
          {
              return "{\"code\":401,\"" + MessageStr + "\":\"Authentication failed\"}";
          }
          public static string ExceptionJson(Exception ex)
          {
              //return "{\"code\":203,\"" + MessageStr + "\":\"" + NoWrap(ex.Message) + "\"}";
              log.Error(ex);
              return "{\"code\":203,\"" + MessageStr + "\":\"error\"}";
          }
          public static string ErrorJson(string str)
          {
              return "{\"code\":203,\"" + MessageStr + "\":\"" + NoWrap(str) + "\"}";
          }
          public static string OperationSuccessJson(string tip = "Operation successful", Dictionary<string, string> AdvKeyValue = null, string NewId = "")
          {
              StringBuilder sb = new StringBuilder();
              if (AdvKeyValue != null)
              {
                  foreach (KeyValuePair<string, string> kv in AdvKeyValue)
                  {
                      sb.Append(",\"" + kv.Key + "\":\"" + NoWrap(kv.Value) + "\"");
                  }
              }
              string json = "{\"code\":200,\"" + MessageStr + "\":\"success\",\"tip\":\"" + tip + "\",\"data\":{\"newId\":\"" + NewId + "\"" + sb.ToString() + "}}";
              sb.Clear();
              sb = null;
              AdvKeyValue.Clear();
              AdvKeyValue = null;
              return json;
          }
          public static string OperationBatchSuccessJson(int rowsAffected, string tip = "Operation successful")
          {
              return "{\"code\":200,\"" + MessageStr + "\":\"success\",\"tip\":\"" + tip + "\",\"data\":{\"rowsAffected\":" + rowsAffected + "}}";
          }
          public static string ResultJson(string resultJson)
          {
              return "{\"code\":200,\"" + MessageStr + "\":\"success\",\"data\":" + resultJson + "}";
          }
          public static string ResultJsonHead()
          {
              return "{\"code\":200,\"" + MessageStr + "\":\"success\",\"data\":";
          }
          private static string NoWrap(string s) => s.Replace("\r", "").Replace("\n", "");
          public readonly static string MessageStr = "msg";
      }
  

   

User

• Define methods for obtaining user information

LoginInfo

• Constructing user login information and returning LoginInfo object

• When integrating with third-party systems or frameworks, it is common to parse or call third-party systems through tokens to obtain user objects

Code

• Server Implementation of @code configuration

• Method of locating the identity to the server through @code configuration

• The parameters for @code configuration are entered as string arrays on the server side

Others

Tools, workflows, scheduled tasks, etc.

Api Instructions for Use

Api Document

Access and log in to the server system, enter the account and password (the account and password are defined in the ft_sites table of the server database, default account is user, password 123), click the login button to enter the online document page.

Click on the button column definition to view more columns by dragging and dropping.

Sequence Parameters

The sequence parameters are concatenated after the interface path, separated by /, and currently support a maximum of 12 sequence parameters, corresponding to the @p[n]@ parameter in the client configuration.

For example, the interface path is: http://[url]/api/a?b. If the @p1@ and @p2@ parameter values to be passed are 1 and 2, respectively, the call path should be:

http://[url]/api/a?b/1/2

If some sequence parameters are required, it should be described in the interface description.

Api Test

Click on the Net or Java link, copy the test address, and then import it in PostMan for direct testing.

The initial message of the input parameter will be automatically filled in without the need for manual input, as shown in the following figure, and can be run directly:

Data List

The Data List is used to retrieve multiple rows of data, including sorting, fuzzy search, precise search, custom conditional search, combination search, page turning definition, etc. It also supports data export, batch specific field modification of data (such as soft deletion, status change), and supports mutual calling between interfaces and nested output.

Permissions, display fields and order, interface nesting, data nesting, logical processing, output definition, function calls, and description are all configured and defined on the client side.

Call Method

Enter parameters through POST, using either Form or Json string format, based on the input column of the interface document.

Input

Output

Referring to the Api documentation, the Json structure is defined by the Project project.

Data Operation

The Data Operation allows for the addition or modification of single or multiple data entries, supporting simultaneous addition and modification of multiple tables, as well as one-time operations on sub tables. The depth of sub tables is not limited, and the client may have already configured data validation rules.

Permissions, input fields, logical processing, transaction processing, backend method calls, and descriptions are all configured and defined on the client side.

Call Method

Enter parameters through POST, using either Form or Json string format, based on the input column of the interface document. If there is binary data (such as file upload), it is recommended to submit it in Form format.

Input

As a Json object, please refer to the Api documentation for details. just as :

Output

Referring to the Api documentation, the Json structure is defined by the Project project.

Data Getting

The Data Getting is used to obtain a single piece of data, mainly used as a detail query. It supports outputting single and multiple table data together, and fields can also output array objects, that is, nested multiple rows of data. It also supports calling interfaces to each other and nested output.

Permissions, display fields and order, interface nesting, data nesting, logical processing, output definition, function calls, and description are all configured and defined on the client side.

Call Method

GET method input

Input

The input parameters are only sequence parameters.

Output

Referring to the Api documentation, the Json structure is defined by the Project project.

Contact Us

d4soft@gmail.com