refactor: 抽取课程考勤记录构建 helper，消除重复代码

apps/server/src/attendance/attendance-lesson.service.ts

@@ -182,36 +182,18 @@ export class AttendanceLessonService {
         );
         for (const classStudent of classStudents) {
           if (existingStudentIds.has(classStudent.studentId)) continue;
-          const raw = selectDingTalkRecordsForLesson(
-            rawByStudent.get(classStudent.studentId) ?? [],
-            schedule,
-            lessonDate,
-          );
-          const resolved = await this.resolveLessonStatus(
-            classStudent.studentId,
-            raw,
-            schedule,
-            lessonDate,
-            effectiveFinalize,
-          );
           updatedRecords.push(
-            recordRepo.create({
+            await this.buildLessonRecord(
-              studentId: classStudent.studentId,
+              recordRepo,
-              student: classStudent.student,
+              rawByStudent,
-              classId: schedule.classId!,
+              classStudent,
+              schedule,
+              lessonDate,
+              lessonSessionKey,
+              existing.id,
               scheduleId,
-              attendanceSessionId: existing.id,
+              effectiveFinalize,
-              attendanceDate: lessonDate,
+            ),
-              session: lessonSessionKey,
-              status: resolved.status,
-              source: 'dingtalk',
-              ...getLessonPunchMetadata(
-                raw,
-                lessonDate,
-                schedule.startTime,
-              ),
-              remark: resolved.remark,
-            }),
           );
         }
 
@@ -274,37 +256,19 @@ export class AttendanceLessonService {
 
       const lessonSessionKey = mapLessonScheduleTimeToSession(schedule.startTime);
       const records = await Promise.all(
-        classStudents.map(async (classStudent) => {
+        classStudents.map((classStudent) =>
-          const raw = selectDingTalkRecordsForLesson(
+          this.buildLessonRecord(
-            rawByStudent.get(classStudent.studentId) ?? [],
+            recordRepo,
+            rawByStudent,
+            classStudent,
             schedule,
             lessonDate,
-          );
+            lessonSessionKey,
-          const resolved = await this.resolveLessonStatus(
+            session.id,
-            classStudent.studentId,
-            raw,
-            schedule,
-            lessonDate,
-            finalize,
-          );
-          return recordRepo.create({
-            studentId: classStudent.studentId,
-            student: classStudent.student,
-            classId: schedule.classId!,
             scheduleId,
-            attendanceSessionId: session.id,
+            finalize,
-            attendanceDate: lessonDate,
+          ),
-            session: lessonSessionKey,
+        ),
-            status: resolved.status,
-            source: 'dingtalk',
-            ...getLessonPunchMetadata(
-              raw,
-              lessonDate,
-              schedule.startTime,
-            ),
-            remark: resolved.remark,
-          });
-        }),
       );
       const saved = await recordRepo.save(records);
       if (finalize) {
@@ -347,6 +311,69 @@ export class AttendanceLessonService {
     return { status: 'absent', remark: '课程截止仍未打卡' };
   }
 
+  private createLessonRecord(
+    recordRepo: Repository<AttendanceRecord>,
+    classStudent: ClassStudent,
+    raw: DingAttendanceRaw[],
+    options: {
+      schedule: Pick<ClassSchedule, 'classId' | 'startTime' | 'endTime' | 'attendanceAdvanceMinutes'>;
+      scheduleId: number;
+      lessonDate: string;
+      lessonSessionKey: string;
+      attendanceSessionId: number;
+      status: string;
+      remark?: string;
+    },
+  ): AttendanceRecord {
+    return recordRepo.create({
+      studentId: classStudent.studentId,
+      student: classStudent.student,
+      classId: options.schedule.classId!,
+      scheduleId: options.scheduleId,
+      attendanceSessionId: options.attendanceSessionId,
+      attendanceDate: options.lessonDate,
+      session: options.lessonSessionKey,
+      status: options.status,
+      source: 'dingtalk',
+      ...getLessonPunchMetadata(raw, options.lessonDate, options.schedule.startTime),
+      remark: options.remark,
+    });
+  }
+
+  private async buildLessonRecord(
+    recordRepo: Repository<AttendanceRecord>,
+    rawByStudent: Map<number, DingAttendanceRaw[]>,
+    classStudent: ClassStudent,
+    schedule: Pick<ClassSchedule, 'classId' | 'startTime' | 'endTime' | 'attendanceAdvanceMinutes'>,
+    lessonDate: string,
+    lessonSessionKey: string,
+    attendanceSessionId: number,
+    scheduleId: number,
+    finalize: boolean,
+  ): Promise<AttendanceRecord> {
+    const raw = selectDingTalkRecordsForLesson(
+      rawByStudent.get(classStudent.studentId) ?? [],
+      schedule,
+      lessonDate,
+    );
+    const resolved = await this.resolveLessonStatus(
+      classStudent.studentId,
+      raw,
+      schedule,
+      lessonDate,
+      finalize,
+    );
+    return this.createLessonRecord(recordRepo, classStudent, raw, {
+      schedule,
+      scheduleId,
+      lessonDate,
+      lessonSessionKey,
+      attendanceSessionId,
+      status: resolved.status,
+      remark: resolved.remark,
+    });
+  }
+
   private async findApprovedLeaveForStudent(
     studentId: number,
     schedule: Pick<ClassSchedule, 'startTime' | 'endTime' | 'attendanceAdvanceMinutes'>,