已删除项目继续从管理员列表和详情中隐藏。

删除后,同一 GitHub 来源可通过“新建迁移”重新拉取,生成新的项目、任务和仓库。
旧任务的“重试迁移”保持原有校验。
This commit is contained in:
lxp
2026-10-29 17:37:44 +08:00
parent bec48bb3ea
commit 37d88683b0
9 changed files with 233 additions and 23 deletions
+1 -1
View File
@@ -228,7 +228,7 @@ bash scripts/migrate-project-covers.sh --execute
### 项目编码与导入流程
普通创建、Fork 和导入的新项目使用 12 位小写项目编码,字符集为 `0123456789abcdefghjkmnpqrstvwxyz`。普通项目用安全随机数生成,项目编码唯一约束冲突最多重试 5 次;其他约束错误不重试。导入编码由 `github-import:v1:<GitHub仓库ID>` 的 SHA-256 前 60 位确定,避免重跑或仓库更名后重复创建。Gitea 仓库名称为 `p_{projectCode}`。历史 32 位编码、仓库及链接继续使用,数据库无需改表。
普通创建、Fork 和导入的新项目使用 12 位小写项目编码,字符集为 `0123456789abcdefghjkmnpqrstvwxyz`。普通项目用安全随机数生成,项目编码唯一约束冲突最多重试 5 次;其他约束错误不重试。首次导入编码由 `github-import:v1:<GitHub仓库ID>` 的 SHA-256 前 60 位确定,避免重跑或仓库更名后重复创建。后台在线迁移仅对未删除项目做来源去重;旧项目删除后再次新建迁移,使用来源与迁移代次生成新编码、新任务和新仓库,重新拉取 GitHub 内容,保留旧记录及仓库。管理员列表和详情仍隐藏已删除项目。已有后台需先执行[来源索引调整 SQL](docs/admin-database.md#允许已删除项目的-github-来源再次迁移本次上线前执行)。Gitea 仓库名称为 `p_{projectCode}`。历史 32 位编码、仓库及链接继续使用,无需因编码长度修改数据库字段。
导入工具仅接受以下固定 Sheet:`1_轮式机器人`、`2_四足机器人`、`3_小人形机器人`、`4_大人形机器人`、`5_机械臂`、`6_其他类型`、`7_开源硬件`。只选 I 列精确为“可访问”、L 列有合法 HTTPS 封面、B 列为具体 GitHub 仓库的行。其他 Sheet 不参与导入;K 列图片公式不会执行。原始 A~H 数据列与表头存在错位,工具按实际位置读取,忽略 H 列的无意义备注 `100`,不将“待查”等信息改写成已确认。
+4 -4
View File
@@ -923,7 +923,7 @@ interface ImportPreview {
预检不创建项目或任务。用返回的 repositoryUrl 作为规范来源;name、description 填入可编辑表单,再选择 projectType、封面和归属。许可证可能未取得,应显示“未识别”,不要视为空许可或默认开源授权。
existingProjectCode 非 null 时提示“已存在项目”,提供进入现有项目详情的入口,不重复创建。预检通过也不保证创建必然成功,创建时仍会重新校验来源和重复记录。
existingProjectCode 只返回未删除项目;非 null 时提示“已存在项目”,提供进入现有项目详情的入口,不重复创建。同一来源对应的旧项目全部删除后返回 null,可以重新填写表单并创建迁移任务。新迁移使用新的 projectCode、taskCode 和仓库,重新拉取 GitHub 内容;旧项目及历史任务不被覆盖,已删除项目仍不出现在管理员列表和详情中。预检通过也不保证创建必然成功,创建时仍会重新校验来源和重复记录。
### 9.2 迁移表单上传封面和 URDF(可选)
@@ -983,7 +983,7 @@ async function uploadImportUrdf(
不上传 URDF 时省略 urdf 或传 null,原有迁移请求保持兼容。若用户已选择 URDF,上传失败时应保留表单并提示,不能静默移除 URDF 后创建任务。
签名与 GitHub 来源绑定;上传后改为另一个仓库,需要重新申请该仓库的签名并上传。来源更名时按 GitHub 稳定身份重新核对。任务创建失败且尚未创建项目时,已上传的同一来源批次可保留用于用户确认后的再次提交,不必覆盖重传文件;查询到 DUPLICATE_SOURCE 则进入已有项目核对,不再重建任务。
签名与 GitHub 来源及本次待创建的项目绑定;上传后改为另一个仓库,需要重新申请该仓库的签名并上传。来源更名时按 GitHub 稳定身份重新核对。任务创建失败且尚未创建项目、来源迁移记录也未变化时,已上传的同一来源批次可保留用于用户确认后的再次提交,不必覆盖重传文件;旧项目删除后再次迁移必须重新申请签名和上传 URDF,不能沿用旧项目的批次。查询到 DUPLICATE_SOURCE 则进入尚未删除的已有项目核对,不再重建任务。
### 9.3 创建任务
@@ -1130,11 +1130,11 @@ async function watchImport(
- canRetry=true 时显示“重试迁移”按钮,用 retryMessage 说明操作并确认;点击后禁用重复提交,收到 202 后恢复轮询。409 表示状态已变化或核验未通过,刷新任务并显示 message,不循环重发。
- 对于明确失败的 `GITEA_MIGRATION_REJECTED`,新任务显示 FAILED。重试后经过 CLEANING:后台核验残留仓库的任务标识、组织、名称、来源及仓库身份,清理后确认不存在,再重新迁移。沿用原 taskCode/projectCode,保留项目资料、封面及 URDF。
- 已取得成功迁移收据时,重试只核验并继续后续步骤,不删除已迁移仓库。项目已 READY、发布过、下架或删除时拒绝重试。
- 已取得成功迁移收据时,重试只核验并继续后续步骤,不删除已迁移仓库。项目已 READY、发布过、下架或删除时拒绝重试。若项目已删除并希望重新拉取 GitHub 内容,应返回“新建迁移”重新预检、提交,创建新的项目和任务;不要对旧任务反复调用 retry。管理员查询仍不显示已删除项目。
- 超时、进程在远端迁移期间中断等未知结果,不自动删除仓库或重发迁移;canRetry=false 时由维护人员处理。清理本身超时或回写中断,可通过重试重新核验目标是否已删除后恢复。
- 旧版本显示 REVIEW 且错误为 GITEA_MIGRATION_REJECTED 的任务,也可以显示重试按钮。若仓库已不存在可以重迁;若仍有残留,但缺少新版本的任务归属标识,则停止清理并返回 REVIEW,避免误删。
- 如果返回 CLEANUP_REPOSITORY_UNSAFE 或 CLEANUP_REPOSITORY_REPLACED,说明残留仓库归属无法核实或身份变化,未删除仓库。项目仍允许恢复时 canRetry=true,retryMessage 提示先人工核对清理;人工删除目标仓库后,刷新并点击同一“重试迁移”按钮即可,无需修改数据库或新建任务。重试仍先核验:仓库依然存在且无法确认归属时继续阻断,确认不存在才重新迁移。canRetry=true 表示允许再次核验,不表示仓库已清理或必然迁移成功。
- 重复来源可能返回 409 `DUPLICATE_SOURCE`,错误 data 中的 projectCode 可用于跳转现有项目。不要改项目名或重新预检后循环创建。
- 同一来源存在未删除项目时返回 409 `DUPLICATE_SOURCE`,错误 data 中的 projectCode 可用于跳转现有项目。若旧项目已全部删除,则允许创建全新的迁移;不要改项目名或循环创建来绕过有效项目的去重。
- 没有取消任务、强行成功、任意删除仓库、定期同步源仓库的接口;失败仓库清理只能通过上述受保护的 retry 流程执行。
- 迁移保留 Git 历史、分支、标签并迁移 LFS;不迁移 Issue、PR、Wiki、Release 附件,不递归复制子模块依赖。保留分支不代表后台可切换分支。
- 原默认分支非 main 时进行适配;已有 main 内容冲突会停止,前端展示任务错误和提醒即可。
+16 -2
View File
@@ -76,7 +76,7 @@ CREATE TABLE project_import_task (
PRIMARY KEY (id),
UNIQUE KEY uk_import_task_code (task_code),
UNIQUE KEY uk_import_project (project_code),
UNIQUE KEY uk_import_source (source_repository_id),
KEY idx_import_source (source_repository_id),
KEY idx_import_queue (status, created_at),
CONSTRAINT fk_import_project FOREIGN KEY (project_code) REFERENCES project(project_code),
CONSTRAINT fk_import_operator FOREIGN KEY (operator_user_code) REFERENCES sys_user(user_code)
@@ -110,7 +110,7 @@ WHERE source_repository_id IS NULL OR source_repository_url IS NULL OR source_de
ALTER TABLE project_import_task MODIFY COLUMN source_repository_id BIGINT NOT NULL COMMENT 'GitHub稳定仓库标识,用于来源去重,仅内部使用';
ALTER TABLE project_import_task MODIFY COLUMN source_repository_url VARCHAR(2048) NOT NULL COMMENT 'GitHub仓库规范公开地址';
ALTER TABLE project_import_task MODIFY COLUMN source_default_branch VARCHAR(255) NOT NULL COMMENT 'GitHub仓库原默认分支,用于分支适配和续跑校验';
ALTER TABLE project_import_task ADD UNIQUE KEY uk_import_source (source_repository_id);
ALTER TABLE project_import_task ADD KEY idx_import_source (source_repository_id);
UPDATE project SET publish_status = 'BLOCKED' WHERE moderation_status = 'BLOCKED' AND deleted = 0;
ALTER TABLE project MODIFY COLUMN publish_status VARCHAR(16) NOT NULL DEFAULT 'UNPUBLISHED' COMMENT '发布状态 UNPUBLISHED未发布 PUBLISHED已发布 BLOCKED管理员下架';
@@ -118,6 +118,20 @@ ALTER TABLE project MODIFY COLUMN publish_status VARCHAR(16) NOT NULL DEFAULT 'U
旧版七个字段及其索引可以暂留,代码已不再读写;确认备份及来源回填完成后再清理。特别是只有旧 Excel 批次、没有后台任务的历史项目,其来源需保留原批次清单或另行归档,不能直接删除唯一来源信息。本次不对实际数据库执行增删字段操作。
## 允许已删除项目的 GitHub 来源再次迁移(本次上线前执行)
仅供已经存在 `uk_import_source` 唯一索引的数据库执行。暂停后台创建迁移任务并备份后,在业务库中手工执行以下 SQL;新建任务表已使用普通索引,无需执行本节。应用不会修改实际表结构。
```sql
ALTER TABLE project_import_task
DROP INDEX uk_import_source,
ADD KEY idx_import_source (source_repository_id);
```
来源标识保留在每条历史任务中,仍通过项目编码关联各自的项目。新版按 GitHub 稳定来源加锁,只对未删除项目去重;已删除项目可用新项目编码、新任务和新仓库再次迁移。旧项目、任务和仓库均保留,不会被覆盖或自动清理;管理员项目列表和详情仍不展示已删除项目。字段与中文注释保持不变。
部署时必须先完成上述索引调整,再更新所有管理端实例;旧索引会继续阻止创建第二条来源任务。允许重复来源后不能直接恢复全局唯一索引,回滚前须核对同一来源的历史任务记录。
## 新建普通文件写入操作记录表(本次上线前执行)
只新增此表,不需要修改项目表。由运维手工执行;应用不自动迁库。时间全部为上海时间(Asia/Shanghai,UTC+8)。
@@ -924,6 +924,131 @@ class AdminWorkflowTest {
assertThat(published.has("externalRepositoryId")).isFalse();
}
private JsonNode previewImport() throws Exception {
return request(signed(body(post("/admin-api/project-imports/preview"),
Map.of("repositoryUrl", "https://github.com/example/robot"))), 200).path("data");
}
@ParameterizedTest
@ValueSource(strings = {"SUCCEEDED", "REVIEW", "FAILED", "QUEUED"})
void deletedImportsStayHiddenAndCanBeMigratedIntoANewProject(String originalStatus) throws Exception {
JsonNode first = createImport();
String oldCode = first.path("projectCode").asText();
String oldTaskCode = first.path("taskCode").asText();
gitea.migrationTimeout = "REVIEW".equals(originalStatus);
gitea.migrationRejected = "FAILED".equals(originalStatus);
if (!"QUEUED".equals(originalStatus)) imports.run(oldTaskCode);
request(signed(delete("/admin-api/projects/" + oldCode)), 200);
request(signed(get("/admin-api/projects/" + oldCode)), 404);
assertThat(request(signed(get("/admin-api/projects")), 200)
.path("data").path("total").asLong()).isZero();
assertThat(previewImport().path("existingProjectCode").isNull()).isTrue();
JsonNode oldTask = request(signed(get("/admin-api/project-imports/" + oldTaskCode)), 200).path("data");
assertThat(oldTask.path("status").asText()).isEqualTo(originalStatus);
assertThat(oldTask.path("canRetry").asBoolean()).isFalse();
request(signed(post("/admin-api/project-imports/" + oldTaskCode + "/retry")), 409);
int previousMigrations = gitea.migrations;
gitea.migrationTimeout = false;
gitea.migrationRejected = false;
JsonNode second = createImport();
String newCode = second.path("projectCode").asText();
String newTaskCode = second.path("taskCode").asText();
assertThat(newCode).isNotEqualTo(oldCode);
assertThat(newTaskCode).isNotEqualTo(oldTaskCode);
assertThat(previewImport().path("existingProjectCode").asText()).isEqualTo(newCode);
assertThat(request(signed(body(post("/admin-api/project-imports"),
Map.of("repositoryUrl", "https://github.com/example/robot", "project", metadata()))), 409)
.path("data").path("projectCode").asText()).isEqualTo(newCode);
imports.run(newTaskCode);
assertThat(request(signed(get("/admin-api/project-imports/" + newTaskCode)), 200)
.path("data").path("status").asText()).isEqualTo("SUCCEEDED");
assertThat(request(signed(get("/admin-api/project-imports/" + oldTaskCode)), 200).path("data"))
.isEqualTo(oldTask);
assertThat(gitea.migrations).isEqualTo(previousMigrations + 1);
assertThat(gitea.deletions).isZero();
assertThat(jdbc.queryForObject("SELECT deleted FROM project WHERE project_code=?", Boolean.class, oldCode))
.isTrue();
JsonNode listed = request(signed(get("/admin-api/projects")), 200).path("data");
assertThat(listed.path("total").asLong()).isEqualTo(1);
assertThat(listed.path("items").get(0).path("project").path("projectCode").asText()).isEqualTo(newCode);
JsonNode detail = request(signed(get("/admin-api/projects/" + newCode)), 200).path("data");
assertThat(detail.path("project").path("sourceRepositoryUrl").asText())
.isEqualTo("https://github.com/example/robot");
assertThat(detail.path("project").has("id")).isFalse();
}
@Test
void multipleDeleteAndReimportCyclesKeepSeparateHistoryAndRepositories() throws Exception {
Set<String> projectCodes = new HashSet<>();
for (int index = 0; index < 3; index++) {
JsonNode task = createImport();
String code = task.path("projectCode").asText();
assertThat(projectCodes.add(code)).isTrue();
imports.run(task.path("taskCode").asText());
assertThat(previewImport().path("existingProjectCode").asText()).isEqualTo(code);
if (index < 2) request(signed(delete("/admin-api/projects/" + code)), 200);
}
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM project_import_task WHERE source_repository_id=?",
Long.class, SOURCES.get())).isEqualTo(3);
assertThat(gitea.migrations).isEqualTo(3);
assertThat(gitea.deletions).isZero();
}
@Test
void reimportUrdfSignaturesUseNewProjectPathsAndRejectTheDeletedProjectsBatch() throws Exception {
enableOss();
JsonNode firstSignature = importUrdfSignature();
storeUrdfFiles(firstSignature);
JsonNode first = request(signed(body(post("/admin-api/project-imports"), importWithUrdf(firstSignature))), 202)
.path("data");
String oldCode = first.path("projectCode").asText();
imports.run(first.path("taskCode").asText());
String oldPrefix = jdbc.queryForObject("SELECT urdf_prefix FROM project WHERE project_code=?", String.class, oldCode);
request(signed(delete("/admin-api/projects/" + oldCode)), 200);
JsonNode nextSignature = importUrdfSignature();
assertThat(nextSignature.path("files").get(0).path("objectKey").asText())
.doesNotContain("/urdf/" + oldCode + "/");
request(signed(body(post("/admin-api/project-imports"), importWithUrdf(firstSignature))), 400);
storeUrdfFiles(nextSignature);
JsonNode second = request(signed(body(post("/admin-api/project-imports"), importWithUrdf(nextSignature))), 202)
.path("data");
String newCode = second.path("projectCode").asText();
assertThat(nextSignature.path("files").get(0).path("objectKey").asText()).contains("/urdf/" + newCode + "/");
imports.run(second.path("taskCode").asText());
assertThat(request(signed(get("/admin-api/projects/" + newCode)), 200)
.path("data").path("project").path("urdfMainUrl").asText()).contains("/urdf/" + newCode + "/");
assertThat(jdbc.queryForObject("SELECT urdf_prefix FROM project WHERE project_code=?", String.class, oldCode))
.isEqualTo(oldPrefix);
}
@Test
void concurrentReimportsOfADeletedSourceCreateOnlyOneActiveProject() throws Exception {
JsonNode oldTask = createImport();
request(signed(delete("/admin-api/projects/" + oldTask.path("projectCode").asText())), 200);
java.util.concurrent.CountDownLatch start = new java.util.concurrent.CountDownLatch(1);
try (java.util.concurrent.ExecutorService executor = java.util.concurrent.Executors.newFixedThreadPool(2)) {
List<java.util.concurrent.Future<Integer>> results = new ArrayList<>();
for (int index = 0; index < 2; index++) {
results.add(executor.submit(() -> {
start.await();
return mvc.perform(signed(body(post("/admin-api/project-imports"),
Map.of("repositoryUrl", "https://github.com/example/robot", "project", metadata()))))
.andReturn().getResponse().getStatus();
}));
}
start.countDown();
List<Integer> statuses = new ArrayList<>();
for (java.util.concurrent.Future<Integer> result : results)
statuses.add(result.get(10, java.util.concurrent.TimeUnit.SECONDS));
assertThat(statuses).containsExactlyInAnyOrder(202, 409);
}
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM project WHERE deleted=0", Long.class)).isEqualTo(1);
assertThat(jdbc.queryForObject("SELECT COUNT(*) FROM project_import_task WHERE source_repository_id=?",
Long.class, SOURCES.get())).isEqualTo(2);
}
@Test
void uncertainMigrationIsNotRepeatedAfterRestartRecovery() throws Exception {
JsonNode task = createImport();
@@ -19,13 +19,19 @@ public final class ProjectCodes {
}
public static String github(long repositoryId) {
return github(repositoryId, 0);
}
/** 同一来源删除后重新迁移时使用新一代编码,避免复用旧项目及其仓库、资源。 */
public static String github(long repositoryId, long generation) {
if (repositoryId <= 0) throw new IllegalArgumentException("GitHub 仓库 ID 必须为正数");
if (generation < 0) throw new IllegalArgumentException("迁移代次不能为负数");
String seed = generation == 0 ? "github-import:v1:" + repositoryId
: "github-import:v2:" + repositoryId + ":" + generation;
try {
byte[] hash =
MessageDigest.getInstance("SHA-256")
.digest(
("github-import:v1:" + repositoryId)
.getBytes(StandardCharsets.UTF_8));
.digest(seed.getBytes(StandardCharsets.UTF_8));
StringBuilder code = new StringBuilder(12);
for (int i = 0; i < 12; i++) {
int offset = i * 5;
@@ -37,4 +37,16 @@ class ProjectCodesTest {
assertThatThrownBy(() -> ProjectCodes.github(0))
.isInstanceOf(IllegalArgumentException.class);
}
@Test
void reimportsUseDistinctStableCodesWhilePreservingFirstImportCodes() {
assertThat(ProjectCodes.github(12345, 0)).isEqualTo(ProjectCodes.github(12345));
assertThat(ProjectCodes.github(12345, 1)).isEqualTo(ProjectCodes.github(12345, 1))
.matches("[0-9abcdefghjkmnpqrstvwxyz]{12}")
.isNotEqualTo(ProjectCodes.github(12345))
.isNotEqualTo(ProjectCodes.github(12345, 2))
.isNotEqualTo(ProjectCodes.github(12346, 1));
assertThatThrownBy(() -> ProjectCodes.github(12345, -1))
.isInstanceOf(IllegalArgumentException.class);
}
}
@@ -79,13 +79,26 @@ public class AdminImportService {
}
private Project existing(long sourceId) {
ProjectImportTask task =
tasks.selectOne(
new LambdaQueryWrapper<ProjectImportTask>()
.eq(ProjectImportTask::getSourceRepositoryId, sourceId));
String code = task == null ? ProjectCodes.github(sourceId) : task.getProjectCode();
Project active = tasks.activeProject(sourceId);
if (active != null) return active;
// 兼容旧命令行导入的项目:可能尚未建立在线迁移任务。
return projects.selectOne(
new LambdaQueryWrapper<Project>().eq(Project::getProjectCode, code));
new LambdaQueryWrapper<Project>()
.eq(Project::getProjectCode, ProjectCodes.github(sourceId))
.eq(Project::getDeleted, false));
}
private String nextProjectCode(long sourceId) {
long generation = tasks.selectCount(
new LambdaQueryWrapper<ProjectImportTask>()
.eq(ProjectImportTask::getSourceRepositoryId, sourceId));
// 跳过旧导入或其他历史记录已经占用的编码,签名与创建可推导出同一目标。
for (int attempt = 0; attempt < 32; attempt++) {
String code = ProjectCodes.github(sourceId, generation + attempt);
if (!projects.exists(new LambdaQueryWrapper<Project>()
.eq(Project::getProjectCode, code))) return code;
}
throw BusinessException.conflict("迁移项目编码无法分配,请联系维护人员核对");
}
private void requireNewSource(long sourceId) {
@@ -104,7 +117,7 @@ public class AdminImportService {
urdfResources.requireEnabled();
GitHubSourceChecks.Repository source = check(input.repositoryUrl());
requireNewSource(source.id());
String code = ProjectCodes.github(source.id());
String code = nextProjectCode(source.id());
UrdfUploadSignature signature = urdfResources.sign(code, input.files());
log.info(
"生成迁移项目 URDF 签名 userCode={} projectCode={} batchCode={} fileCount={}",
@@ -119,7 +132,7 @@ public class AdminImportService {
private PreparedUrdf prepareUrdf(String projectCode, UrdfConfirmInput input) {
if (input == null) return null;
// 项目编码由重新校验的 GitHub 稳定标识生成,不能借用其他项目的上传批次。
// 项目编码由重新校验的 GitHub 稳定标识和迁移代次生成,不能借用其他项目的上传批次。
// OSS 核验在数据库事务及项目锁之外完成,不依赖尚未创建的 Git 仓库。
urdfResources.verify(projectCode, input.batchCode(), input.files());
String prefix = urdfResources.prefix(projectCode, input.batchCode());
@@ -132,14 +145,17 @@ public class AdminImportService {
rateLimits.operation("create", 0);
ProjectInputs.validate(input.project(), properties);
GitHubSourceChecks.Repository source = check(input.repositoryUrl());
String code = ProjectCodes.github(source.id());
requireNewSource(source.id());
String code = nextProjectCode(source.id());
PreparedUrdf urdf = prepareUrdf(code, input.urdf());
User owner = management.owner(input.ownerUserCode());
return locks.serial(
code,
// 各次迁移的项目编码不同,来源锁始终使用首代编码,防止并发创建两个有效项目。
ProjectCodes.github(source.id()),
() -> {
requireNewSource(source.id());
if (!code.equals(nextProjectCode(source.id())))
throw BusinessException.conflict("来源迁移记录已变化,请刷新并重新申请上传签名");
try {
return transactions.execute(
status -> {
@@ -182,10 +198,11 @@ public class AdminImportService {
task.setUpdatedAt(task.getCreatedAt());
tasks.insert(task);
log.info(
"创建迁移任务 userCode={} taskCode={} projectCode={}",
"创建迁移任务 userCode={} taskCode={} projectCode={} reimport={}",
task.getOperatorUserCode(),
task.getTaskCode(),
code);
code,
!code.equals(ProjectCodes.github(source.id())));
if (urdf != null)
log.info(
"迁移项目绑定 URDF userCode={} taskCode={} projectCode={}"
@@ -1,6 +1,17 @@
package com.linkerbot.vibemake.service.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.linkerbot.vibemake.bean.entity.Project;
import com.linkerbot.vibemake.bean.entity.ProjectImportTask;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
public interface ProjectImportTaskMapper extends BaseMapper<ProjectImportTask> {}
public interface ProjectImportTaskMapper extends BaseMapper<ProjectImportTask> {
@Select("""
SELECT p.* FROM project p
JOIN project_import_task t ON t.project_code = p.project_code
WHERE t.source_repository_id = #{sourceId} AND p.deleted = 0
ORDER BY t.id DESC LIMIT 1
""")
Project activeProject(@Param("sourceId") long sourceId);
}
@@ -0,0 +1,25 @@
package com.linkerbot.vibemake.service.support;
import static org.assertj.core.api.Assertions.assertThat;
import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import org.junit.jupiter.api.Test;
class ProjectSupportTest {
@Test
void businessTimeCrossesMidnightInShanghai() {
assertThat(ProjectSupport.fromInstant(Instant.parse("2026-12-31T16:00:00.123Z")))
.isEqualTo(LocalDateTime.parse("2027-01-01T00:00:00.123"));
}
@Test
void currentBusinessTimeRepresentsTheCurrentInstantInShanghai() {
Instant before = Instant.now();
LocalDateTime now = ProjectSupport.now();
Instant after = Instant.now();
assertThat(now.atZone(ZoneId.of("Asia/Shanghai")).toInstant()).isBetween(before, after);
}
}