# EasyCode Front Workbench Implementation Plan

> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.

**Goal:** Build an independent EasyCode front workbench where front users log in, generate editable MySQL table drafts through a backend DeepSeek service, preview backend/frontend/admin project files, and download generated source.

**Architecture:** Add a standalone `easycode-web` Vue 3 + Vite app for public/front-user flows. Add `/front/**` APIs to `ruoyi-admin`, store front-user drafts in new `front_*` tables under `ruoyi-generator`, call DeepSeek only through backend `AiGenerateService`, and reuse the existing generator rendering logic for preview/download.

**Tech Stack:** Spring Boot 2.5, Spring Security, MyBatis XML, Fastjson2, Velocity generator, Vue 3, Vite, Vue Router, Axios, Element Plus, Sass.

---

## Scope Check

This is a cross-cutting feature, but the pieces are sequential parts of one product workflow:

1. Database/auth foundation.
2. Project draft and editable database design.
3. DeepSeek-backed database generation.
4. Generator preview/download adaptation.
5. Independent front app and end-to-end integration.

Implement in the task order below. Each task should end with tests and a commit.

## File Map

### SQL

- Create `sql/front_workbench.sql`: standalone DDL for new front-user and draft tables.
- Modify `sql/db.sql`: include the same DDL so a fresh database has the front workbench tables.

### Common and Framework

- Modify `ruoyi-common/src/main/java/com/ruoyi/common/constant/Constants.java`: add login type constants.
- Modify `ruoyi-common/src/main/java/com/ruoyi/common/core/domain/model/LoginUser.java`: add `loginType`.
- Modify `ruoyi-framework/src/main/java/com/ruoyi/framework/security/filter/JwtAuthenticationTokenFilter.java`: prevent front tokens from authenticating non-`/front/**` requests, and prevent admin tokens from authenticating protected `/front/**` requests.
- Modify `ruoyi-framework/src/main/java/com/ruoyi/framework/config/SecurityConfig.java`: allow anonymous `/front/auth/login` and `/front/auth/register`.
- Modify `ruoyi-framework/src/main/java/com/ruoyi/framework/web/service/SysLoginService.java`: mark admin logins as admin tokens.

### Generator Module

- Create domain classes under `ruoyi-generator/src/main/java/com/ruoyi/generator/domain/front/`:
  - `FrontUser.java`
  - `FrontProject.java`
  - `FrontProjectTable.java`
  - `FrontProjectColumn.java`
  - `FrontProjectGeneration.java`
  - `FrontProjectFile.java`
- Create DTO classes under `ruoyi-generator/src/main/java/com/ruoyi/generator/domain/front/dto/`:
  - `FrontLoginBody.java`
  - `FrontRegisterBody.java`
  - `FrontProjectCreateRequest.java`
  - `FrontProjectUpdateRequest.java`
  - `GenerateDatabaseRequest.java`
  - `DatabaseDesignResponse.java`
  - `DatabaseTableDesign.java`
  - `DatabaseColumnDesign.java`
  - `PreviewFileRequest.java`
  - `ProjectStructureResponse.java`
- Create mappers under `ruoyi-generator/src/main/java/com/ruoyi/generator/mapper/front/`:
  - `FrontUserMapper.java`
  - `FrontProjectMapper.java`
  - `FrontProjectTableMapper.java`
  - `FrontProjectColumnMapper.java`
  - `FrontProjectGenerationMapper.java`
  - `FrontProjectFileMapper.java`
- Create mapper XML under `ruoyi-generator/src/main/resources/mapper/front/` with matching names.
- Create services under `ruoyi-generator/src/main/java/com/ruoyi/generator/service/front/`:
  - `IFrontUserService.java`
  - `FrontUserServiceImpl.java`
  - `IFrontProjectService.java`
  - `FrontProjectServiceImpl.java`
  - `IAiGenerateService.java`
  - `AiGenerateServiceImpl.java`
  - `IDeepSeekClient.java`
  - `HttpDeepSeekClient.java`
  - `AiDatabaseSchemaValidator.java`
  - `MysqlDdlBuilder.java`
  - `FrontProjectConverter.java`
  - `IFrontProjectPreviewService.java`
  - `FrontProjectPreviewServiceImpl.java`
- Modify `ruoyi-generator/src/main/java/com/ruoyi/generator/config/`:
  - Create `DeepSeekProperties.java`.
- Modify existing generator rendering:
  - `ruoyi-generator/src/main/java/com/ruoyi/generator/service/IGenProjectService.java`
  - `ruoyi-generator/src/main/java/com/ruoyi/generator/service/GenProjectServiceImpl.java`
  Add overloads that accept a transient `GenProject` with draft tables.

### Admin Controllers

- Create `ruoyi-admin/src/main/java/com/ruoyi/web/controller/front/FrontAuthController.java`.
- Create `ruoyi-admin/src/main/java/com/ruoyi/web/controller/front/FrontProjectController.java`.
- Create `ruoyi-admin/src/main/java/com/ruoyi/web/service/front/FrontAuthService.java`.

### Front App

- Create project root `easycode-web/`.
- Create `easycode-web/package.json`, `vite.config.js`, `index.html`, `.env.development`, `.env.production`.
- Create app files:
  - `easycode-web/src/main.js`
  - `easycode-web/src/App.vue`
  - `easycode-web/src/router/index.js`
  - `easycode-web/src/api/request.js`
  - `easycode-web/src/api/auth.js`
  - `easycode-web/src/api/project.js`
  - `easycode-web/src/utils/auth.js`
  - `easycode-web/src/styles/global.scss`
  - `easycode-web/src/components/AppHeader.vue`
  - `easycode-web/src/components/DatabaseDesigner.vue`
  - `easycode-web/src/components/ProjectStructureTree.vue`
  - `easycode-web/src/components/CodePreview.vue`
  - `easycode-web/src/views/HomeView.vue`
  - `easycode-web/src/views/LoginView.vue`
  - `easycode-web/src/views/RegisterView.vue`
  - `easycode-web/src/views/GenerateView.vue`
  - `easycode-web/src/views/PreviewView.vue`

---

## Task 1: Add Front Workbench Database Tables

**Files:**
- Create: `sql/front_workbench.sql`
- Modify: `sql/db.sql`

- [ ] **Step 1: Write the DDL script**

Create `sql/front_workbench.sql` with this schema. Use `utf8mb4`, `innodb`, and `front_` prefixes.

```sql
-- =================================================
-- EasyCode front workbench tables
-- Import after sql/db.sql, or use the copy appended to sql/db.sql
-- =================================================

drop table if exists front_project_file;
drop table if exists front_project_generation;
drop table if exists front_project_column;
drop table if exists front_project_table;
drop table if exists front_project;
drop table if exists front_user;

create table front_user (
  user_id              bigint(20)      not null auto_increment comment '前台用户ID',
  username             varchar(50)     not null comment '用户名',
  password             varchar(100)    not null comment '密码',
  nickname             varchar(50)     default '' comment '昵称',
  email                varchar(100)    default '' comment '邮箱',
  phone                varchar(20)     default '' comment '手机号',
  status               char(1)         default '0' comment '状态（0正常 1停用）',
  del_flag             char(1)         default '0' comment '删除标志（0存在 2删除）',
  last_login_time      datetime        default null comment '最后登录时间',
  create_time          datetime        default null comment '创建时间',
  update_time          datetime        default null comment '更新时间',
  remark               varchar(500)    default null comment '备注',
  primary key (user_id),
  unique key uk_front_user_username (username),
  key idx_front_user_email (email),
  key idx_front_user_phone (phone)
) engine=innodb auto_increment=100 comment='前台用户表';

create table front_project (
  project_id           bigint(20)      not null auto_increment comment '前台项目ID',
  user_id              bigint(20)      not null comment '前台用户ID',
  project_name         varchar(100)    not null comment '项目名称',
  project_file_name    varchar(100)    default '' comment '项目文件名',
  package_name         varchar(100)    default 'com.easycode.generated' comment '包名',
  version              varchar(20)     default '1.0.0' comment '版本号',
  project_desc         varchar(1000)   default '' comment '项目描述',
  industry_template    varchar(50)     default '' comment '行业模板',
  front_framework      varchar(50)     default 'Vue3 + Element Plus' comment '前台框架',
  back_framework       varchar(50)     default 'Spring Boot + MyBatis' comment '后端框架',
  generate_status      char(1)         default '0' comment '数据库生成状态（0未生成 1生成中 2已生成 3失败）',
  preview_status       char(1)         default '0' comment '预览状态（0未预览 1已预览 2失败）',
  status               char(1)         default '0' comment '状态（0正常 1停用）',
  create_time          datetime        default null comment '创建时间',
  update_time          datetime        default null comment '更新时间',
  remark               varchar(500)    default null comment '备注',
  primary key (project_id),
  key idx_front_project_user_id (user_id),
  constraint fk_front_project_user foreign key (user_id) references front_user(user_id)
) engine=innodb auto_increment=100 comment='前台项目草稿表';

create table front_project_table (
  table_id             bigint(20)      not null auto_increment comment '表设计ID',
  project_id           bigint(20)      not null comment '项目ID',
  user_id              bigint(20)      not null comment '前台用户ID',
  table_name           varchar(200)    not null comment '表名称',
  table_comment        varchar(500)    default '' comment '表描述',
  class_name           varchar(100)    default '' comment '实体类名称',
  module_name          varchar(30)     default '' comment '生成模块名',
  business_name        varchar(30)     default '' comment '生成业务名',
  function_name        varchar(50)     default '' comment '生成功能名',
  tpl_category         varchar(200)    default 'crud' comment '模板类型',
  tpl_web_type         varchar(30)     default 'element-plus' comment '前端模板类型',
  options              varchar(1000)   default '' comment '生成选项',
  create_table_sql     longtext        comment '建表SQL',
  sort                 int             default 0 comment '排序',
  status               char(1)         default '0' comment '状态（0正常 1停用）',
  create_time          datetime        default null comment '创建时间',
  update_time          datetime        default null comment '更新时间',
  primary key (table_id),
  unique key uk_front_project_table (project_id, table_name),
  key idx_front_project_table_project_id (project_id),
  constraint fk_front_project_table_project foreign key (project_id) references front_project(project_id)
) engine=innodb auto_increment=100 comment='前台项目表设计';

create table front_project_column (
  column_id            bigint(20)      not null auto_increment comment '字段设计ID',
  table_id             bigint(20)      not null comment '表设计ID',
  project_id           bigint(20)      not null comment '项目ID',
  column_name          varchar(200)    not null comment '字段名称',
  column_comment       varchar(500)    default '' comment '字段描述',
  column_type          varchar(100)    not null comment '字段类型',
  java_type            varchar(500)    default 'String' comment 'Java类型',
  java_field           varchar(200)    default '' comment 'Java字段名',
  is_pk                char(1)         default '0' comment '是否主键（1是）',
  is_increment         char(1)         default '0' comment '是否自增（1是）',
  is_required          char(1)         default '0' comment '是否必填（1是）',
  is_insert            char(1)         default '1' comment '是否插入字段（1是）',
  is_edit              char(1)         default '1' comment '是否编辑字段（1是）',
  is_list              char(1)         default '1' comment '是否列表字段（1是）',
  is_query             char(1)         default '0' comment '是否查询字段（1是）',
  query_type           varchar(200)    default 'EQ' comment '查询方式',
  html_type            varchar(200)    default 'input' comment '显示类型',
  dict_type            varchar(200)    default '' comment '字典类型',
  default_value        varchar(200)    default null comment '默认值',
  sort                 int             default 0 comment '排序',
  create_time          datetime        default null comment '创建时间',
  update_time          datetime        default null comment '更新时间',
  primary key (column_id),
  key idx_front_project_column_table_id (table_id),
  key idx_front_project_column_project_id (project_id),
  constraint fk_front_project_column_table foreign key (table_id) references front_project_table(table_id)
) engine=innodb auto_increment=100 comment='前台项目字段设计';

create table front_project_generation (
  generation_id        bigint(20)      not null auto_increment comment '生成记录ID',
  project_id           bigint(20)      not null comment '项目ID',
  user_id              bigint(20)      not null comment '前台用户ID',
  generate_type        varchar(50)     not null comment '生成类型',
  provider             varchar(50)     default 'deepseek' comment 'AI提供方',
  prompt_summary       varchar(500)    default '' comment 'Prompt摘要',
  request_payload      longtext        comment '请求内容',
  response_payload     longtext        comment '响应内容',
  success              char(1)         default '0' comment '是否成功（1成功 0失败）',
  error_message        varchar(1000)   default '' comment '错误信息',
  token_usage          int             default 0 comment 'Token用量',
  elapsed_ms           bigint(20)      default 0 comment '耗时毫秒',
  create_time          datetime        default null comment '创建时间',
  primary key (generation_id),
  key idx_front_project_generation_project_id (project_id)
) engine=innodb auto_increment=100 comment='前台项目生成记录';

create table front_project_file (
  file_id              bigint(20)      not null auto_increment comment '文件缓存ID',
  project_id           bigint(20)      not null comment '项目ID',
  template_type        varchar(50)     not null comment '模板类型',
  node_id              varchar(100)    default '' comment '结构节点ID',
  table_id             bigint(20)      default null comment '表设计ID',
  file_name            varchar(255)    not null comment '文件名',
  file_path            varchar(500)    default '' comment '文件路径',
  file_content         longtext        comment '文件内容',
  content_hash         varchar(64)     default '' comment '内容哈希',
  create_time          datetime        default null comment '创建时间',
  update_time          datetime        default null comment '更新时间',
  primary key (file_id),
  key idx_front_project_file_project_id (project_id),
  key idx_front_project_file_lookup (project_id, template_type, table_id)
) engine=innodb auto_increment=100 comment='前台项目预览文件缓存';
```

- [ ] **Step 2: Append the same DDL to `sql/db.sql`**

Place it after the existing generator extension tables and before `SET FOREIGN_KEY_CHECKS = 1;`. Keep `drop table if exists` order from child tables to parent tables.

- [ ] **Step 3: Run SQL static checks**

Run:

```powershell
git diff --check -- sql/db.sql sql/front_workbench.sql
rg -n "create table front_user|create table front_project|front_project_generation" sql/db.sql sql/front_workbench.sql
```

Expected:

```text
git diff --check has no output
rg prints all six new front_* table declarations
```

- [ ] **Step 4: Commit**

```powershell
git add sql/db.sql sql/front_workbench.sql
git commit -m "Add front workbench database schema"
```

---

## Task 2: Add Front Token Isolation

**Files:**
- Modify: `ruoyi-common/src/main/java/com/ruoyi/common/constant/Constants.java`
- Modify: `ruoyi-common/src/main/java/com/ruoyi/common/core/domain/model/LoginUser.java`
- Modify: `ruoyi-framework/src/main/java/com/ruoyi/framework/web/service/SysLoginService.java`
- Modify: `ruoyi-framework/src/main/java/com/ruoyi/framework/security/filter/JwtAuthenticationTokenFilter.java`
- Modify: `ruoyi-framework/src/main/java/com/ruoyi/framework/config/SecurityConfig.java`

- [ ] **Step 1: Add login type constants**

In `Constants.java`, add:

```java
/** 后台管理端登录类型 */
public static final String LOGIN_TYPE_ADMIN = "admin";

/** 前台用户登录类型 */
public static final String LOGIN_TYPE_FRONT = "front";
```

- [ ] **Step 2: Add `loginType` to `LoginUser`**

Add field, getter, and setter:

```java
/** 登录类型：admin 后台用户，front 前台用户 */
private String loginType;

public String getLoginType()
{
    return loginType;
}

public void setLoginType(String loginType)
{
    this.loginType = loginType;
}
```

Keep existing constructors unchanged. Existing tokens with `loginType == null` must be treated as admin-compatible.

- [ ] **Step 3: Mark existing admin logins**

In `SysLoginService.login`, immediately after:

```java
LoginUser loginUser = (LoginUser) authentication.getPrincipal();
```

add:

```java
loginUser.setLoginType(Constants.LOGIN_TYPE_ADMIN);
```

- [ ] **Step 4: Gate front/admin tokens in JWT filter**

In `JwtAuthenticationTokenFilter`, add helper methods:

```java
private boolean isFrontRequest(HttpServletRequest request)
{
    return request.getRequestURI() != null && request.getRequestURI().startsWith("/front/");
}

private boolean isTokenAllowedForRequest(LoginUser loginUser, HttpServletRequest request)
{
    String loginType = loginUser.getLoginType();
    boolean frontRequest = isFrontRequest(request);
    if (frontRequest)
    {
        return com.ruoyi.common.constant.Constants.LOGIN_TYPE_FRONT.equals(loginType);
    }
    return loginType == null || com.ruoyi.common.constant.Constants.LOGIN_TYPE_ADMIN.equals(loginType);
}
```

Then change the existing authentication block to:

```java
if (StringUtils.isNotNull(loginUser)
        && isTokenAllowedForRequest(loginUser, request)
        && StringUtils.isNull(SecurityUtils.getAuthentication()))
{
    tokenService.verifyToken(loginUser);
    UsernamePasswordAuthenticationToken authenticationToken =
            new UsernamePasswordAuthenticationToken(loginUser, null, loginUser.getAuthorities());
    authenticationToken.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));
    SecurityContextHolder.getContext().setAuthentication(authenticationToken);
}
```

- [ ] **Step 5: Permit front login/register anonymously**

In `SecurityConfig.filterChain`, extend the anonymous matcher:

```java
requests.antMatchers("/login", "/register", "/captchaImage",
        "/front/auth/login", "/front/auth/register").permitAll()
```

Do not permit all `/front/**`.

- [ ] **Step 6: Run backend compile**

Run:

```powershell
mvn -pl ruoyi-admin -am -DskipTests package
```

Expected:

```text
[INFO] BUILD SUCCESS
```

- [ ] **Step 7: Commit**

```powershell
git add ruoyi-common/src/main/java/com/ruoyi/common/constant/Constants.java `
  ruoyi-common/src/main/java/com/ruoyi/common/core/domain/model/LoginUser.java `
  ruoyi-framework/src/main/java/com/ruoyi/framework/web/service/SysLoginService.java `
  ruoyi-framework/src/main/java/com/ruoyi/framework/security/filter/JwtAuthenticationTokenFilter.java `
  ruoyi-framework/src/main/java/com/ruoyi/framework/config/SecurityConfig.java
git commit -m "Separate front and admin login tokens"
```

---

## Task 3: Add Front Domain, Mappers, and Basic Services

**Files:**
- Create: front domain classes, mapper interfaces, mapper XML, and basic service interfaces/impls listed in File Map.
- Test: `ruoyi-generator/src/test/java/com/ruoyi/generator/service/front/FrontProjectConverterTest.java`

- [ ] **Step 1: Create front domain classes**

Each domain class extends `BaseEntity` where timestamps and remark are needed. Use JavaBean getters/setters, not Lombok.

`FrontUser` fields:

```java
private Long userId;
private String username;
private String password;
private String nickname;
private String email;
private String phone;
private String status;
private String delFlag;
private Date lastLoginTime;
```

`FrontProject` fields:

```java
private Long projectId;
private Long userId;
private String projectName;
private String projectFileName;
private String packageName;
private String version;
private String projectDesc;
private String industryTemplate;
private String frontFramework;
private String backFramework;
private String generateStatus;
private String previewStatus;
private String status;
private List<FrontProjectTable> tables;
```

`FrontProjectTable` fields:

```java
private Long tableId;
private Long projectId;
private Long userId;
private String tableName;
private String tableComment;
private String className;
private String moduleName;
private String businessName;
private String functionName;
private String tplCategory;
private String tplWebType;
private String options;
private String createTableSql;
private Integer sort;
private String status;
private List<FrontProjectColumn> columns;
```

`FrontProjectColumn` fields:

```java
private Long columnId;
private Long tableId;
private Long projectId;
private String columnName;
private String columnComment;
private String columnType;
private String javaType;
private String javaField;
private String isPk;
private String isIncrement;
private String isRequired;
private String isInsert;
private String isEdit;
private String isList;
private String isQuery;
private String queryType;
private String htmlType;
private String dictType;
private String defaultValue;
private Integer sort;
```

`FrontProjectGeneration` and `FrontProjectFile` mirror the SQL columns.

- [ ] **Step 2: Create mapper interfaces**

Use this shape for every mapper:

```java
public interface FrontProjectMapper
{
    FrontProject selectFrontProjectById(Long projectId);

    List<FrontProject> selectFrontProjectList(FrontProject frontProject);

    int insertFrontProject(FrontProject frontProject);

    int updateFrontProject(FrontProject frontProject);

    int deleteFrontProjectById(Long projectId);
}
```

Add ownership-specific methods where needed:

```java
FrontProject selectFrontProjectByUserAndId(@Param("userId") Long userId, @Param("projectId") Long projectId);
int deleteFrontProjectByUserAndId(@Param("userId") Long userId, @Param("projectId") Long projectId);
```

For table and column mappers add:

```java
List<FrontProjectTable> selectTablesByProjectId(Long projectId);
int deleteTablesByProjectId(Long projectId);
List<FrontProjectColumn> selectColumnsByTableId(Long tableId);
int deleteColumnsByProjectId(Long projectId);
```

- [ ] **Step 3: Create mapper XML**

Follow the existing XML style in `mapper/generator/*.xml`. Every XML must contain:

```xml
<resultMap type="FrontProject" id="FrontProjectResult">
    <id property="projectId" column="project_id" />
    <result property="userId" column="user_id" />
    <result property="projectName" column="project_name" />
    <result property="projectFileName" column="project_file_name" />
    <result property="packageName" column="package_name" />
    <result property="version" column="version" />
    <result property="projectDesc" column="project_desc" />
    <result property="industryTemplate" column="industry_template" />
    <result property="frontFramework" column="front_framework" />
    <result property="backFramework" column="back_framework" />
    <result property="generateStatus" column="generate_status" />
    <result property="previewStatus" column="preview_status" />
    <result property="status" column="status" />
    <result property="createTime" column="create_time" />
    <result property="updateTime" column="update_time" />
    <result property="remark" column="remark" />
</resultMap>
```

Use `useGeneratedKeys="true"` and `keyProperty` for inserts.

- [ ] **Step 4: Create basic services**

`IFrontProjectService` must expose:

```java
FrontProject createProject(Long userId, FrontProjectCreateRequest request);
List<FrontProject> listProjects(Long userId);
FrontProject getProject(Long userId, Long projectId);
int updateProject(Long userId, Long projectId, FrontProjectUpdateRequest request);
int deleteProject(Long userId, Long projectId);
DatabaseDesignResponse getDatabase(Long userId, Long projectId);
DatabaseDesignResponse saveDatabase(Long userId, Long projectId, DatabaseDesignResponse request);
```

`saveDatabase` must delete old `front_project_column`, then old `front_project_table`, then insert the submitted table/column tree in one transaction.

- [ ] **Step 5: Write converter test first**

Create `FrontProjectConverterTest` with this test:

```java
@Test
public void convertsFrontDraftToGenProject()
{
    FrontProject project = new FrontProject();
    project.setProjectId(10L);
    project.setProjectName("车辆管理系统");
    project.setProjectFileName("vehicle-system");
    project.setPackageName("com.easycode.vehicle");
    project.setVersion("1.0.0");
    project.setFrontFramework("Vue3 + Element Plus");
    project.setBackFramework("Spring Boot + MyBatis");

    FrontProjectTable table = new FrontProjectTable();
    table.setTableId(20L);
    table.setTableName("car_info");
    table.setTableComment("车辆信息表");
    table.setClassName("CarInfo");
    table.setModuleName("vehicle");
    table.setBusinessName("car");
    table.setFunctionName("车辆信息");

    FrontProjectColumn column = new FrontProjectColumn();
    column.setColumnId(30L);
    column.setColumnName("car_id");
    column.setColumnComment("车辆ID");
    column.setColumnType("bigint(20)");
    column.setJavaType("Long");
    column.setJavaField("carId");
    column.setIsPk("1");
    column.setIsIncrement("1");
    table.setColumns(Collections.singletonList(column));
    project.setTables(Collections.singletonList(table));

    GenProject genProject = FrontProjectConverter.toGenProject(project);

    assertEquals("车辆管理系统", genProject.getProjectName());
    assertEquals("com.easycode.vehicle", genProject.getPackageName());
    assertEquals(1, genProject.getTables().size());
    assertEquals("car_info", genProject.getTables().get(0).getTableName());
    assertEquals("carId", genProject.getTables().get(0).getColumns().get(0).getJavaField());
}
```

- [ ] **Step 6: Run test and verify failure**

Run:

```powershell
mvn -pl ruoyi-generator -am -Dtest=FrontProjectConverterTest test
```

Expected before converter implementation:

```text
Compilation failure: cannot find symbol FrontProjectConverter
```

- [ ] **Step 7: Implement `FrontProjectConverter`**

Implement exact conversion rules:

- `FrontProject.projectId` maps to `GenProject.projectId`.
- `FrontProject.projectName` maps to `GenProject.projectName`.
- `FrontProject.projectFileName` maps to `GenProject.projectFileName`.
- `FrontProject.packageName` maps to `GenProject.packageName`.
- `FrontProject.version` maps to `GenProject.version`.
- `FrontProject.frontFramework` maps to `GenProject.frontFramework`.
- `FrontProject.backFramework` maps to `GenProject.backFramework`.
- Each `FrontProjectTable` maps to `GenTable`.
- Each `FrontProjectColumn` maps to `GenTableColumn`.

- [ ] **Step 8: Run tests**

Run:

```powershell
mvn -pl ruoyi-generator -am -Dtest=FrontProjectConverterTest test
```

Expected:

```text
Tests run: 1, Failures: 0, Errors: 0
```

- [ ] **Step 9: Commit**

```powershell
git add ruoyi-generator/src/main/java/com/ruoyi/generator/domain/front `
  ruoyi-generator/src/main/java/com/ruoyi/generator/mapper/front `
  ruoyi-generator/src/main/resources/mapper/front `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/front `
  ruoyi-generator/src/test/java/com/ruoyi/generator/service/front/FrontProjectConverterTest.java
git commit -m "Add front project draft model"
```

---

## Task 4: Add Front Authentication APIs

**Files:**
- Create: `ruoyi-admin/src/main/java/com/ruoyi/web/service/front/FrontAuthService.java`
- Create: `ruoyi-admin/src/main/java/com/ruoyi/web/controller/front/FrontAuthController.java`
- Create DTOs if not already created:
  - `FrontLoginBody.java`
  - `FrontRegisterBody.java`
- Modify: `IFrontUserService.java`, `FrontUserServiceImpl.java`

- [ ] **Step 1: Add front user service methods**

`IFrontUserService` must include:

```java
FrontUser selectByUsername(String username);
FrontUser selectById(Long userId);
int register(FrontRegisterBody body);
int updateLastLoginTime(Long userId);
```

Registration rules:

- username required, length 2 to 50
- password required, length 5 to 50
- duplicate username raises `ServiceException("前台账号已存在")`
- password stored with `SecurityUtils.encryptPassword`
- default nickname is username
- default status is `"0"`
- default delFlag is `"0"`

- [ ] **Step 2: Implement front auth service**

`FrontAuthService.login` must:

1. Load front user by username.
2. Reject missing user, disabled user, deleted user, and wrong password.
3. Build a `SysUser` object only for token compatibility.
4. Build a `LoginUser`.
5. Set `loginType` to `Constants.LOGIN_TYPE_FRONT`.
6. Set permissions to `Collections.emptySet()`.
7. Call `tokenService.createToken(loginUser)`.
8. Update `last_login_time`.

Core snippet:

```java
SysUser tokenUser = new SysUser();
tokenUser.setUserId(frontUser.getUserId());
tokenUser.setUserName(frontUser.getUsername());
tokenUser.setNickName(frontUser.getNickname());
tokenUser.setPassword(frontUser.getPassword());

LoginUser loginUser = new LoginUser(frontUser.getUserId(), null, tokenUser, Collections.emptySet());
loginUser.setLoginType(Constants.LOGIN_TYPE_FRONT);
String token = tokenService.createToken(loginUser);
frontUserService.updateLastLoginTime(frontUser.getUserId());
return token;
```

- [ ] **Step 3: Implement controller**

`FrontAuthController` endpoints:

```java
@RestController
@RequestMapping("/front/auth")
public class FrontAuthController extends BaseController
{
    @PostMapping("/register")
    public AjaxResult register(@RequestBody FrontRegisterBody body)

    @PostMapping("/login")
    public AjaxResult login(@RequestBody FrontLoginBody body)

    @GetMapping("/profile")
    public AjaxResult profile()

    @PostMapping("/logout")
    public AjaxResult logout()
}
```

`login` returns:

```java
AjaxResult ajax = AjaxResult.success();
ajax.put(Constants.TOKEN, token);
return ajax;
```

`profile` returns the front user from `FrontUserService.selectById(SecurityUtils.getUserId())`.

- [ ] **Step 4: Add service test**

Create `ruoyi-admin/src/test/java/com/ruoyi/web/service/front/FrontAuthServiceTest.java`. Add test dependencies to `ruoyi-admin/pom.xml` if missing:

```xml
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.mockito</groupId>
    <artifactId>mockito-core</artifactId>
    <scope>test</scope>
</dependency>
```

Test:

```java
@Test
public void loginCreatesFrontToken()
{
    FrontUser user = new FrontUser();
    user.setUserId(100L);
    user.setUsername("demo");
    user.setNickname("Demo");
    user.setPassword(SecurityUtils.encryptPassword("admin123"));
    user.setStatus("0");
    user.setDelFlag("0");

    when(frontUserService.selectByUsername("demo")).thenReturn(user);
    when(tokenService.createToken(any(LoginUser.class))).thenAnswer(invocation -> {
        LoginUser loginUser = invocation.getArgument(0);
        assertEquals(Constants.LOGIN_TYPE_FRONT, loginUser.getLoginType());
        assertEquals(Long.valueOf(100L), loginUser.getUserId());
        return "front-token";
    });

    String token = frontAuthService.login("demo", "admin123");

    assertEquals("front-token", token);
    verify(frontUserService).updateLastLoginTime(100L);
}
```

- [ ] **Step 5: Run tests**

Run:

```powershell
mvn -pl ruoyi-admin -am -Dtest=FrontAuthServiceTest test
```

Expected:

```text
Tests run: 1, Failures: 0, Errors: 0
```

- [ ] **Step 6: Commit**

```powershell
git add ruoyi-admin/src/main/java/com/ruoyi/web/controller/front/FrontAuthController.java `
  ruoyi-admin/src/main/java/com/ruoyi/web/service/front/FrontAuthService.java `
  ruoyi-admin/src/test/java/com/ruoyi/web/service/front/FrontAuthServiceTest.java `
  ruoyi-admin/pom.xml `
  ruoyi-generator/src/main/java/com/ruoyi/generator/domain/front/dto/FrontLoginBody.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/domain/front/dto/FrontRegisterBody.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/front/IFrontUserService.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/front/FrontUserServiceImpl.java
git commit -m "Add front user authentication"
```

---

## Task 5: Add Project Draft APIs and Editable Database Save

**Files:**
- Create: `ruoyi-admin/src/main/java/com/ruoyi/web/controller/front/FrontProjectController.java`
- Modify: `IFrontProjectService.java`
- Modify: `FrontProjectServiceImpl.java`
- Create/modify DTO classes for project create/update/database response.

- [ ] **Step 1: Implement project CRUD controller**

Controller methods:

```java
@RestController
@RequestMapping("/front/project")
public class FrontProjectController extends BaseController
{
    @Autowired
    private IFrontProjectService frontProjectService;

    @PostMapping("/create")
    public AjaxResult create(@RequestBody FrontProjectCreateRequest request)

    @GetMapping("/list")
    public AjaxResult list()

    @GetMapping("/{projectId}")
    public AjaxResult get(@PathVariable Long projectId)

    @PutMapping("/{projectId}")
    public AjaxResult update(@PathVariable Long projectId, @RequestBody FrontProjectUpdateRequest request)

    @DeleteMapping("/{projectId}")
    public AjaxResult delete(@PathVariable Long projectId)

    @GetMapping("/{projectId}/database")
    public AjaxResult database(@PathVariable Long projectId)

    @PutMapping("/{projectId}/database")
    public AjaxResult saveDatabase(@PathVariable Long projectId, @RequestBody DatabaseDesignResponse request)
}
```

Every method gets `Long userId = SecurityUtils.getUserId()` and only touches rows owned by that `userId`.

- [ ] **Step 2: Implement project create defaults**

`FrontProjectServiceImpl.createProject` must default:

```java
projectFileName = lower hyphen form of projectName, e.g. "车辆管理系统" -> "easycode-project"
packageName = request.packageName if present else "com.easycode.generated"
version = request.version if present else "1.0.0"
frontFramework = "Vue3 + Element Plus"
backFramework = "Spring Boot + MyBatis"
generateStatus = "0"
previewStatus = "0"
status = "0"
```

When Chinese project names cannot be slugified safely, use `"easycode-project-" + System.currentTimeMillis()`.

- [ ] **Step 3: Implement `getDatabase`**

Return:

```java
DatabaseDesignResponse response = new DatabaseDesignResponse();
response.setProjectId(projectId);
response.setTables(tableDesigns);
response.setSql(joinedCreateTableSql);
```

Join SQL with two line breaks between tables.

- [ ] **Step 4: Implement `saveDatabase` validation**

Before saving:

- project must belong to user
- at least one table
- every table name matches `^[a-z][a-z0-9_]{1,63}$`
- every table has at least one column
- every column name matches `^[a-z][a-z0-9_]{1,63}$`
- every column type passes `AiDatabaseSchemaValidator.isAllowedColumnType`
- exactly one primary key per table

Raise `ServiceException` with messages:

```text
项目不存在或无权限
至少需要一张数据表
表名只能包含小写字母、数字和下划线
每张表至少需要一个字段
字段名只能包含小写字母、数字和下划线
字段类型不在允许范围内
每张表必须且只能有一个主键
```

- [ ] **Step 5: Run generator tests**

Run:

```powershell
mvn -pl ruoyi-generator -am -DfailIfNoTests=false test
```

Expected:

```text
[INFO] BUILD SUCCESS
```

- [ ] **Step 6: Commit**

```powershell
git add ruoyi-admin/src/main/java/com/ruoyi/web/controller/front/FrontProjectController.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/domain/front/dto `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/front/IFrontProjectService.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/front/FrontProjectServiceImpl.java
git commit -m "Add front project draft APIs"
```

---

## Task 6: Add DeepSeek-backed AI Database Generation

**Files:**
- Create: `ruoyi-generator/src/main/java/com/ruoyi/generator/config/DeepSeekProperties.java`
- Create/modify: `IAiGenerateService.java`, `AiGenerateServiceImpl.java`, `IDeepSeekClient.java`, `HttpDeepSeekClient.java`, `AiDatabaseSchemaValidator.java`, `MysqlDdlBuilder.java`
- Modify: `FrontProjectController.java`
- Modify: `application.yml`
- Test: `AiDatabaseSchemaValidatorTest.java`, `MysqlDdlBuilderTest.java`, `AiGenerateServiceImplTest.java`

- [ ] **Step 1: Add DeepSeek config properties**

Create:

```java
@Component
@ConfigurationProperties(prefix = "deepseek")
public class DeepSeekProperties
{
    private String apiKey;
    private String baseUrl = "https://api.deepseek.com";
    private String model = "deepseek-chat";
    private Integer timeout = 60000;
    private Integer maxTables = 12;
    private Integer maxColumnsPerTable = 30;

    // getters and setters
}
```

Add to `application.yml`:

```yaml
deepseek:
  apiKey: ${DEEPSEEK_API_KEY:}
  baseUrl: https://api.deepseek.com
  model: deepseek-chat
  timeout: 60000
  maxTables: 12
  maxColumnsPerTable: 30
```

- [ ] **Step 2: Implement DeepSeek client**

`IDeepSeekClient`:

```java
public interface IDeepSeekClient
{
    String chat(String prompt);
}
```

`HttpDeepSeekClient` uses `RestTemplate`. Request:

```json
{
  "model": "deepseek-chat",
  "messages": [
    {"role": "system", "content": "你是企业管理系统数据库设计助手，只返回JSON。"},
    {"role": "user", "content": "<prompt>"}
  ],
  "temperature": 0.2
}
```

Response parser returns `choices[0].message.content`. If `apiKey` is blank, throw:

```java
throw new ServiceException("DeepSeek API Key 未配置");
```

- [ ] **Step 3: Implement validator**

Allowed type patterns:

```java
private static final Pattern NAME = Pattern.compile("^[a-z][a-z0-9_]{1,63}$");
private static final Pattern BIGINT = Pattern.compile("^bigint(\\(20\\))?$");
private static final Pattern INT = Pattern.compile("^int(\\(11\\))?$");
private static final Pattern VARCHAR = Pattern.compile("^varchar\\(([1-9][0-9]{0,2}|1000)\\)$");
private static final Pattern CHAR = Pattern.compile("^char\\(([1-9][0-9]?)\\)$");
private static final Pattern DECIMAL = Pattern.compile("^decimal\\(([1-9][0-9]?),([1-9][0-9]?)\\)$");
```

Also allow exact:

```text
datetime, date, text, longtext
```

Reject SQL containing case-insensitive:

```text
drop, truncate, alter user, grant, revoke, load_file, into outfile
```

- [ ] **Step 4: Implement DDL builder**

For each table produce:

```sql
CREATE TABLE `car_info` (
  `car_id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '车辆ID',
  `car_no` varchar(30) NOT NULL COMMENT '车牌号',
  PRIMARY KEY (`car_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='车辆信息表';
```

Rules:

- primary key with `isIncrement == "1"` gets `AUTO_INCREMENT`
- required field gets `NOT NULL`
- optional field gets `DEFAULT NULL`
- string comments escape single quote as doubled single quote
- one DDL string per table saved to `FrontProjectTable.createTableSql`

- [ ] **Step 5: Write validator tests**

Test cases:

```java
assertTrue(validator.isValidName("car_info"));
assertFalse(validator.isValidName("CarInfo"));
assertFalse(validator.isValidName("sys user"));
assertTrue(validator.isAllowedColumnType("varchar(100)"));
assertTrue(validator.isAllowedColumnType("decimal(10,2)"));
assertFalse(validator.isAllowedColumnType("json"));
assertFalse(validator.isSafeSql("drop table sys_user"));
```

- [ ] **Step 6: Write AI service test with mocked client**

Mock response:

```json
{
  "tables": [
    {
      "tableName": "car_info",
      "tableComment": "车辆信息表",
      "columns": [
        {
          "columnName": "car_id",
          "columnType": "bigint(20)",
          "javaType": "Long",
          "javaField": "carId",
          "isPk": "1",
          "isIncrement": "1",
          "isRequired": "1",
          "columnComment": "车辆ID"
        },
        {
          "columnName": "car_no",
          "columnType": "varchar(30)",
          "javaType": "String",
          "javaField": "carNo",
          "isPk": "0",
          "isIncrement": "0",
          "isRequired": "1",
          "columnComment": "车牌号"
        }
      ]
    }
  ]
}
```

Expected:

- inserts one `front_project_table`
- inserts two `front_project_column`
- saves one generation record with `success = "1"`
- returns SQL containing `CREATE TABLE \`car_info\``

- [ ] **Step 7: Add controller endpoint**

In `FrontProjectController`:

```java
@PostMapping("/{projectId}/generate-database")
public AjaxResult generateDatabase(@PathVariable Long projectId, @RequestBody GenerateDatabaseRequest request)
{
    Long userId = SecurityUtils.getUserId();
    return success(aiGenerateService.generateDatabase(userId, projectId, request));
}
```

- [ ] **Step 8: Run tests**

Run:

```powershell
mvn -pl ruoyi-generator -am -Dtest=AiDatabaseSchemaValidatorTest,MysqlDdlBuilderTest,AiGenerateServiceImplTest test
```

Expected:

```text
Tests run: at least 3, Failures: 0, Errors: 0
```

- [ ] **Step 9: Commit**

```powershell
git add ruoyi-admin/src/main/resources/application.yml `
  ruoyi-admin/src/main/java/com/ruoyi/web/controller/front/FrontProjectController.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/config/DeepSeekProperties.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/front `
  ruoyi-generator/src/test/java/com/ruoyi/generator/service/front
git commit -m "Add DeepSeek database generation service"
```

---

## Task 7: Adapt Generator Preview for Front Drafts

**Files:**
- Modify: `IGenProjectService.java`
- Modify: `GenProjectServiceImpl.java`
- Create/modify: `IFrontProjectPreviewService.java`, `FrontProjectPreviewServiceImpl.java`
- Modify: `FrontProjectController.java`
- Test: `FrontProjectPreviewServiceImplTest.java`

- [ ] **Step 1: Add generator overloads**

In `IGenProjectService`, add:

```java
List<Map<String, Object>> getProjectStructure(GenProject project, String type);

Map<String, String> previewCode(GenProject project, Long tableId, String keyword, String type);

byte[] downloadStructure(GenProject project, String type);
```

Existing ID-based methods stay unchanged and delegate to the new object-based overload after loading `GenProject`.

- [ ] **Step 2: Refactor `GenProjectServiceImpl`**

The object overload must not query `gen_project` by ID. It may still query active templates and project structures.

Template resolution rules:

1. If a project has a `sys_project_template` row for `project.projectId` and `type`, use it.
2. Otherwise choose the first active `sys_template` where `template_type = type`.
3. If none exists, throw `ServiceException("未配置可用模板：" + type)`.

Structure query rules:

- For admin projects, keep existing project template structure lookup.
- For front draft projects without `sys_project_template`, use `sys_project_structure` nodes for the resolved template ID.
- Expand table-scoped nodes for every `GenTable` in `project.getTables()`.

- [ ] **Step 3: Implement front preview service**

`IFrontProjectPreviewService`:

```java
List<Map<String, Object>> getStructure(Long userId, Long projectId, String templateType);
Map<String, String> getFileContent(Long userId, Long projectId, PreviewFileRequest request);
byte[] download(Long userId, Long projectId, String templateType);
```

Implementation:

1. Load `FrontProject` with tables and columns by user/project ID.
2. Convert to `GenProject`.
3. Call `genProjectService.getProjectStructure(genProject, templateType)`.
4. Call `genProjectService.previewCode(genProject, tableId, category, templateType)` for file content.
5. Call `genProjectService.downloadStructure(genProject, templateType)` for zip.

- [ ] **Step 4: Add preview endpoints**

In `FrontProjectController`:

```java
@PostMapping("/{projectId}/preview")
public AjaxResult preview(@PathVariable Long projectId)

@GetMapping("/{projectId}/structure")
public AjaxResult structure(@PathVariable Long projectId, @RequestParam String templateType)

@GetMapping("/{projectId}/file-content")
public AjaxResult fileContent(@PathVariable Long projectId, PreviewFileRequest request)

@GetMapping("/{projectId}/download")
public void download(@PathVariable Long projectId, @RequestParam String templateType, HttpServletResponse response)
```

`preview` marks `front_project.preview_status = "1"` after structure can be generated for `backend`, `frontend`, and `admin_frontend`.

- [ ] **Step 5: Write preview service test**

Test:

```java
@Test
public void returnsStructureForDraftProject()
{
    when(frontProjectService.getProject(100L, 200L)).thenReturn(frontProjectWithOneTable());
    when(genProjectService.getProjectStructure(any(GenProject.class), eq("backend")))
            .thenReturn(Collections.singletonList(Collections.singletonMap("label", "backend")));

    List<Map<String, Object>> structure = previewService.getStructure(100L, 200L, "backend");

    assertEquals("backend", structure.get(0).get("label"));
}
```

- [ ] **Step 6: Run tests**

Run:

```powershell
mvn -pl ruoyi-generator -am -Dtest=FrontProjectPreviewServiceImplTest,GenProjectServiceImplTest test
```

Expected:

```text
Tests run: existing generator tests plus preview test, Failures: 0, Errors: 0
```

- [ ] **Step 7: Commit**

```powershell
git add ruoyi-generator/src/main/java/com/ruoyi/generator/service/IGenProjectService.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/GenProjectServiceImpl.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/front/IFrontProjectPreviewService.java `
  ruoyi-generator/src/main/java/com/ruoyi/generator/service/front/FrontProjectPreviewServiceImpl.java `
  ruoyi-admin/src/main/java/com/ruoyi/web/controller/front/FrontProjectController.java `
  ruoyi-generator/src/test/java/com/ruoyi/generator/service/front/FrontProjectPreviewServiceImplTest.java
git commit -m "Support front draft project preview"
```

---

## Task 8: Scaffold Independent `easycode-web`

**Files:**
- Create all `easycode-web` files listed in File Map.

- [ ] **Step 1: Create package and Vite config**

`easycode-web/package.json`:

```json
{
  "name": "easycode-web",
  "version": "1.0.0",
  "private": true,
  "type": "module",
  "scripts": {
    "dev": "vite --host 0.0.0.0",
    "build": "vite build",
    "preview": "vite preview --host 0.0.0.0"
  },
  "dependencies": {
    "@element-plus/icons-vue": "^2.3.1",
    "axios": "^1.7.9",
    "element-plus": "^2.9.1",
    "vue": "^3.5.13",
    "vue-router": "^4.5.0"
  },
  "devDependencies": {
    "@vitejs/plugin-vue": "^5.2.1",
    "sass": "^1.83.0",
    "vite": "^6.0.7"
  }
}
```

`easycode-web/vite.config.js`:

```js
import { defineConfig, loadEnv } from 'vite'
import vue from '@vitejs/plugin-vue'

export default defineConfig(({ mode }) => {
  const env = loadEnv(mode, process.cwd())
  return {
    plugins: [vue()],
    server: {
      port: 5174,
      proxy: {
        '/front': {
          target: env.VITE_API_BASE_URL || 'http://localhost:8080',
          changeOrigin: true
        }
      }
    }
  }
})
```

`.env.development`:

```env
VITE_API_BASE_URL=http://localhost:8080
```

- [ ] **Step 2: Create router guard**

`easycode-web/src/router/index.js`:

```js
import { createRouter, createWebHistory } from 'vue-router'
import { getToken } from '@/utils/auth'

const routes = [
  { path: '/', name: 'Home', component: () => import('@/views/HomeView.vue') },
  { path: '/login', name: 'Login', component: () => import('@/views/LoginView.vue') },
  { path: '/register', name: 'Register', component: () => import('@/views/RegisterView.vue') },
  { path: '/generate', name: 'Generate', component: () => import('@/views/GenerateView.vue'), meta: { requiresAuth: true } },
  { path: '/project/:projectId/preview', name: 'Preview', component: () => import('@/views/PreviewView.vue'), meta: { requiresAuth: true } }
]

const router = createRouter({
  history: createWebHistory(),
  routes
})

router.beforeEach((to) => {
  if (to.meta.requiresAuth && !getToken()) {
    return { path: '/login', query: { redirect: to.fullPath } }
  }
  return true
})

export default router
```

- [ ] **Step 3: Create request wrapper**

`easycode-web/src/api/request.js`:

```js
import axios from 'axios'
import { ElMessage } from 'element-plus'
import { getToken, removeToken } from '@/utils/auth'

const service = axios.create({
  baseURL: '',
  timeout: 60000
})

service.interceptors.request.use((config) => {
  const token = getToken()
  if (token) {
    config.headers.Authorization = `Bearer ${token}`
  }
  return config
})

service.interceptors.response.use(
  (response) => {
    const data = response.data
    if (data && data.code && data.code !== 200) {
      ElMessage.error(data.msg || '请求失败')
      return Promise.reject(new Error(data.msg || '请求失败'))
    }
    return data
  },
  (error) => {
    if (error.response && error.response.status === 401) {
      removeToken()
      ElMessage.error('登录已过期，请重新登录')
    } else {
      ElMessage.error(error.message || '网络异常')
    }
    return Promise.reject(error)
  }
)

export default service
```

- [ ] **Step 4: Create home page**

Use the prototype as content reference but write clean Vue and Chinese text. Keep the first viewport as the usable generation entry, not a marketing-only page.

Hero actions:

```js
const startGenerate = () => {
  router.push({
    path: '/generate',
    query: { keyword: keyword.value }
  })
}
```

Login action:

```js
router.push('/login')
```

- [ ] **Step 5: Create generate page with mock fallback**

`GenerateView.vue` must support these states:

```js
const activeStep = ref(0)
const generating = ref(false)
const projectId = ref(null)
const database = ref({ tables: [], sql: '' })
```

Buttons:

- “生成数据库” calls `createProject`, then `generateDatabase`.
- “保存表结构” calls `saveDatabase`.
- “预览项目” routes to `/project/${projectId}/preview`.

- [ ] **Step 6: Create preview page**

`PreviewView.vue` loads three structures:

```js
const templateTypes = [
  { label: '后端项目', value: 'backend' },
  { label: '前台前端', value: 'frontend' },
  { label: '后台前端', value: 'admin_frontend' }
]
```

Clicking a file node calls:

```js
getFileContent(projectId, {
  templateType: activeTemplateType.value,
  nodeId: node.id,
  tableId: node.tableId,
  category: node.category
})
```

- [ ] **Step 7: Install and build**

Run:

```powershell
cd easycode-web
npm install
npm run build
```

Expected:

```text
vite build succeeds and creates easycode-web/dist
```

If `npm install` fails because network access is blocked, rerun with escalation and keep the same command.

- [ ] **Step 8: Commit**

```powershell
git add easycode-web
git commit -m "Add EasyCode front web app"
```

---

## Task 9: Wire Front App to Real APIs

**Files:**
- Modify: `easycode-web/src/api/auth.js`
- Modify: `easycode-web/src/api/project.js`
- Modify: `easycode-web/src/views/LoginView.vue`
- Modify: `easycode-web/src/views/RegisterView.vue`
- Modify: `easycode-web/src/views/GenerateView.vue`
- Modify: `easycode-web/src/views/PreviewView.vue`

- [ ] **Step 1: Implement auth API**

`auth.js`:

```js
import request from './request'

export function login(data) {
  return request.post('/front/auth/login', data)
}

export function register(data) {
  return request.post('/front/auth/register', data)
}

export function profile() {
  return request.get('/front/auth/profile')
}
```

- [ ] **Step 2: Implement project API**

`project.js`:

```js
import request from './request'

function unwrap(res) {
  return res && Object.prototype.hasOwnProperty.call(res, 'data') ? res.data : res
}

export function createProject(data) {
  return request.post('/front/project/create', data).then(unwrap)
}

export function generateDatabase(projectId, data) {
  return request.post(`/front/project/${projectId}/generate-database`, data).then(unwrap)
}

export function getDatabase(projectId) {
  return request.get(`/front/project/${projectId}/database`).then(unwrap)
}

export function saveDatabase(projectId, data) {
  return request.put(`/front/project/${projectId}/database`, data).then(unwrap)
}

export function getStructure(projectId, templateType) {
  return request.get(`/front/project/${projectId}/structure`, { params: { templateType } }).then(unwrap)
}

export function getFileContent(projectId, params) {
  return request.get(`/front/project/${projectId}/file-content`, { params }).then(unwrap)
}
```

- [ ] **Step 3: Use token from login**

On successful login:

```js
const res = await login(form)
setToken(res.token)
router.push(route.query.redirect || '/generate')
```

- [ ] **Step 4: Wire generate page**

On “生成数据库”:

```js
const project = await createProject({
  projectName: form.projectName,
  projectDesc: form.projectDesc,
  industryTemplate: form.industryTemplate
})
projectId.value = project.projectId
const result = await generateDatabase(projectId.value, form)
database.value = result
activeStep.value = 1
```

The `unwrap` helper in `project.js` normalizes `AjaxResult.success(data)` to the inner `data` object.

- [ ] **Step 5: Wire preview page**

Load structures after route enter:

```js
for (const item of templateTypes) {
  const res = await getStructure(projectId, item.value)
  structures.value[item.value] = res || []
}
```

Click file node:

```js
const res = await getFileContent(projectId, {
  templateType: activeTemplateType.value,
  nodeId: node.id,
  tableId: node.tableId,
  category: node.category
})
code.value = res && res.content ? res.content : ''
fileName.value = node.label
```

- [ ] **Step 6: Build front app**

Run:

```powershell
cd easycode-web
npm run build
```

Expected:

```text
vite build succeeds
```

- [ ] **Step 7: Commit**

```powershell
git add easycode-web/src
git commit -m "Connect front web app to workbench APIs"
```

---

## Task 10: End-to-End Verification and Documentation

**Files:**
- Modify: `README.md`
- Create or modify: `easycode-web/README.md`
- Optional create: `sql/front_workbench_test_data.sql`

- [ ] **Step 1: Add front app README**

`easycode-web/README.md` must include:

```markdown
# EasyCode Web

## Start

```powershell
npm install
npm run dev
```

Default URL: http://localhost:5174

## Backend

Set `VITE_API_BASE_URL` in `.env.development`.

## Flow

1. Register or login front user.
2. Enter project name and description.
3. Generate MySQL database design through backend DeepSeek service.
4. Edit tables and fields.
5. Preview backend, frontend, and admin frontend project files.
```
```

- [ ] **Step 2: Update root README**

Add a short “前台生成工作台” section with:

```markdown
### 前台生成工作台

- 前台目录：`easycode-web`
- 后台接口前缀：`/front/**`
- DeepSeek 只在后端 `AiGenerateService` 中调用
- 新增数据库脚本：`sql/front_workbench.sql`
```

- [ ] **Step 3: Backend verification**

Run:

```powershell
mvn -pl ruoyi-admin -am -DfailIfNoTests=false test
```

Expected:

```text
[INFO] BUILD SUCCESS
```

- [ ] **Step 4: Frontend verification**

Run:

```powershell
cd easycode-web
npm run build
```

Expected:

```text
vite build succeeds
```

- [ ] **Step 5: Manual smoke test**

Start backend and front app. Use these checks:

```text
1. Open http://localhost:5174
2. Click 登录 and register a front user
3. Login redirects back to /generate
4. Create project "车辆管理系统"
5. Click 生成数据库
6. Tables are displayed and editable
7. Save database design
8. Click 预览项目
9. backend/frontend/admin_frontend structures load
10. Click a file and code appears on the right
```

- [ ] **Step 6: Commit**

```powershell
git add README.md easycode-web/README.md
git commit -m "Document front workbench setup"
```

---

## Final Verification Before Merge

Run from repository root:

```powershell
git status -sb
git diff --check
mvn -pl ruoyi-admin -am -DfailIfNoTests=false test
```

Run from `easycode-web`:

```powershell
npm run build
```

Expected:

```text
working tree clean after final commit
git diff --check has no output
Maven BUILD SUCCESS
Vite build succeeds
```

## Implementation Notes

- Keep DeepSeek API key only in backend environment/config.
- Do not add DeepSeek calls to `easycode-web`.
- Use front token only for `/front/**`.
- Do not reuse `sys_user` for front users.
- Do not save AI output directly without `AiDatabaseSchemaValidator`.
- Keep generated draft data in `front_*` tables; only convert to `GenProject` in memory for preview/download.
