dianshang-houduan/src/test/java/com/sztzjy/linkCommerce/service/impl/TrainingTaskServiceImplTest.java

package com.sztzjy.linkCommerce.service.impl;

import com.sztzjy.linkCommerce.config.security.JwtUser;
import com.sztzjy.linkCommerce.entity.SchoolClass;
import com.sztzjy.linkCommerce.entity.TeachingClassStudent;
import com.sztzjy.linkCommerce.entity.TrainingTask;
import com.sztzjy.linkCommerce.entity.TrainingTaskClassConfig;
import com.sztzjy.linkCommerce.entity.importDto.TrainingTaskImportDTO;
import com.sztzjy.linkCommerce.mapper.SchoolClassMapper;
import com.sztzjy.linkCommerce.mapper.TeachingClassStudentMapper;
import com.sztzjy.linkCommerce.mapper.TrainingTaskClassConfigMapper;
import com.sztzjy.linkCommerce.mapper.TrainingTaskMapper;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.springframework.jdbc.core.JdbcTemplate;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.ArgumentMatchers.startsWith;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoInteractions;
import static org.mockito.Mockito.when;

class TrainingTaskServiceImplTest {

    @Test
    void splitListSupportsCommonSeparators() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();

        List<String> result = service.splitList("one;two|three");

        assertEquals(3, result.size());
        assertEquals("one", result.get(0));
        assertEquals("three", result.get(2));
    }

    @Test
    void importTaskValidatesRequiredFields() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        TrainingTaskImportDTO row = new TrainingTaskImportDTO();
        row.setTaskName("Teacher Title");
        List<String> errors = new ArrayList<>();

        TrainingTask task = service.buildTask(row, 2, errors);

        assertEquals(null, task);
        assertFalse(errors.isEmpty());
    }

    @Test
    void importTaskAllowsTeacherEditedTaskNameForBuiltInTask() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        TrainingTaskImportDTO row = new TrainingTaskImportDTO();
        row.setProjectName("Foundation");
        row.setTaskKey("new-product-survey");
        row.setTaskName("Teacher Edited Survey");
        row.setSteps("s1;s2");
        List<String> errors = new ArrayList<>();

        TrainingTask task = service.buildTask(row, 2, errors);

        assertEquals(0, errors.size());
        assertEquals("Teacher Edited Survey", task.getTaskName());
        assertEquals("[\"s1\",\"s2\",\"Step 3\",\"Step 4\"]", task.getSteps());
    }

    @Test
    void importTaskRejectsUnknownTaskKeyBecauseTaskCountIsFixed() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        TrainingTaskImportDTO row = new TrainingTaskImportDTO();
        row.setProjectName("Custom");
        row.setTaskKey("custom-task");
        row.setTaskName("Custom Task");
        List<String> errors = new ArrayList<>();

        TrainingTask task = service.buildTask(row, 2, errors);

        assertEquals(null, task);
        assertFalse(errors.isEmpty());
    }

    @Test
    void updateTaskPersistsTeacherEditedTaskNameAndFixedStepCount() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        TrainingTask stored = storedTask("task-1", "new-product-survey");
        when(service.trainingTaskMapper.selectByPrimaryKey("task-1")).thenReturn(stored);

        TrainingTask payload = new TrainingTask();
        payload.setProjectName("Changed Project Should Be Ignored");
        payload.setTaskKey("unknown-key-should-be-ignored");
        payload.setTaskName("Teacher Edited Survey");
        payload.setSteps("[\"Only One\"]");

        service.update("task-1", payload);

        ArgumentCaptor<TrainingTask> captor = ArgumentCaptor.forClass(TrainingTask.class);
        verify(service.trainingTaskMapper).updateByPrimaryKeySelective(captor.capture());
        assertEquals("new-product-survey", captor.getValue().getTaskKey());
        assertEquals("Foundation", captor.getValue().getProjectName());
        assertEquals("Teacher Edited Survey", captor.getValue().getTaskName());
        assertEquals("[\"Only One\",\"Step 2\",\"Step 3\",\"Step 4\"]", captor.getValue().getSteps());
    }

    @Test
    void createRejectsUnknownTaskKeyBecauseTaskCountIsFixed() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        TrainingTask task = new TrainingTask();
        task.setProjectName("Custom");
        task.setTaskKey("custom-task");
        task.setTaskName("Custom Task");

        assertThrows(IllegalArgumentException.class, () -> service.create(task, "teacher-1"));
    }

    @Test
    void deleteRejectsBuiltInTaskBecauseTaskCountIsFixed() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);

        assertThrows(IllegalArgumentException.class, () -> service.delete("task-1"));
    }

    @Test
    void importTaskUpdatesExistingTaskByTaskKey() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);

        TrainingTask existing = storedTask("task-1", "new-product-survey");
        when(service.trainingTaskMapper.selectByTaskKey("new-product-survey")).thenReturn(existing);
        when(service.trainingTaskMapper.selectByPrimaryKey("task-1")).thenReturn(existing);

        TrainingTaskImportDTO row = new TrainingTaskImportDTO();
        row.setProjectName("Foundation");
        row.setTaskKey("new-product-survey");
        row.setTaskName("Teacher Edited Survey");
        row.setObjectives("goal1;goal2");
        row.setSteps("s1;s2;s3;s4;s5");
        row.setEnabled("true");

        List<String> errors = new ArrayList<>();
        int count = service.importTasks(Collections.singletonList(row), "teacher-1", errors);

        assertEquals(1, count);
        assertEquals(0, errors.size());
        ArgumentCaptor<TrainingTask> captor = ArgumentCaptor.forClass(TrainingTask.class);
        verify(service.trainingTaskMapper).updateByPrimaryKeySelective(captor.capture());
        assertEquals("task-1", captor.getValue().getId());
        assertEquals("Teacher Edited Survey", captor.getValue().getTaskName());
        assertEquals("[\"s1\",\"s2\",\"s3\",\"s4\"]", captor.getValue().getSteps());
    }

    @Test
    void importTaskRejectsMissingBuiltInRecordRatherThanCreatingNewTask() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        when(service.trainingTaskMapper.selectByTaskKey("new-product-survey")).thenReturn(null);

        TrainingTaskImportDTO row = new TrainingTaskImportDTO();
        row.setProjectName("Foundation");
        row.setTaskKey("new-product-survey");
        row.setTaskName("Teacher Edited Survey");
        row.setObjectives("goal1;goal2");
        row.setSteps("s1;s2;s3;s4");
        row.setEnabled("true");

        List<String> errors = new ArrayList<>();
        int count = service.importTasks(Collections.singletonList(row), "teacher-1", errors);

        assertEquals(0, count);
        assertFalse(errors.isEmpty());
        verify(service.trainingTaskMapper, never()).insertSelective(any());
    }

    @Test
    void ensureDefaultTasksBackfillsMissingBuiltInTasksWhenTableAlreadyHasData() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);

        TrainingTask existing = storedTask("task-1", "new-product-survey");
        when(service.trainingTaskMapper.selectByTaskKey("new-product-survey")).thenReturn(existing);

        service.ensureDefaultTasks("system");

        ArgumentCaptor<TrainingTask> captor = ArgumentCaptor.forClass(TrainingTask.class);
        verify(service.trainingTaskMapper, times(22)).insertSelective(captor.capture());
        assertFalse(captor.getAllValues().stream().anyMatch(task -> "new-product-survey".equals(task.getTaskKey())));
        assertEquals("product-development-factors", captor.getAllValues().get(0).getTaskKey());
    }

    @Test
    void ensureDefaultTasksCreatesTrainingTaskTableBeforeQuerying() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.jdbcTemplate = mock(JdbcTemplate.class);

        service.ensureDefaultTasks("system");

        verify(service.jdbcTemplate).execute(startsWith("CREATE TABLE IF NOT EXISTS training_task ("));
        verify(service.jdbcTemplate).execute("ALTER TABLE training_task CONVERT TO CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci");
    }

    @Test
    void ensureDefaultTasksCreatesClassConfigTableBeforeClassScopedQueries() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.jdbcTemplate = mock(JdbcTemplate.class);

        service.ensureDefaultTasks("system");

        verify(service.jdbcTemplate).execute(startsWith("CREATE TABLE IF NOT EXISTS training_task_class_config"));
    }

    @Test
    void listDoesNotFilterDisabledTasksWhenEnabledOnlyIsFalse() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        when(service.trainingTaskMapper.selectByTaskKey(any())).thenReturn(new TrainingTask());
        TrainingTask disabledTask = new TrainingTask();
        disabledTask.setEnabled(Boolean.FALSE);
        when(service.trainingTaskMapper.selectList(isNull(), isNull(), isNull()))
                .thenReturn(Collections.singletonList(disabledTask));

        List<TrainingTask> result = service.list(null, null, false);

        assertEquals(1, result.size());
        assertFalse(result.get(0).getEnabled());
        verify(service.trainingTaskMapper, times(2)).selectList(isNull(), isNull(), isNull());
    }

    @Test
    void studentTaskUsesClassOverrideBeforeDefault() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.teachingClassStudentMapper = mock(TeachingClassStudentMapper.class);

        TeachingClassStudent membership = new TeachingClassStudent();
        membership.setTeachingClassId("class-1");
        when(service.teachingClassStudentMapper.selectActiveByStudentUserId("stu-1")).thenReturn(membership);

        TrainingTask defaultTask = storedTask("task-1", "new-product-survey");
        defaultTask.setTaskName("Default Name");
        defaultTask.setKnowledge("Default Knowledge");
        when(service.trainingTaskMapper.selectByTaskKey("new-product-survey")).thenReturn(defaultTask);

        TrainingTaskClassConfig override = overrideTask("config-1", "class-1", "new-product-survey");
        override.setTaskName("Class Name");
        override.setKnowledge("Class Knowledge");
        override.setEnabled(Boolean.TRUE);
        when(service.trainingTaskClassConfigMapper.selectByTeachingClassAndTaskKey("class-1", "new-product-survey")).thenReturn(override);

        TrainingTask result = service.getStudentTaskByTaskKey("new-product-survey", "stu-1");

        assertEquals("Class Name", result.getTaskName());
        assertEquals("Class Knowledge", result.getKnowledge());
    }

    @Test
    void studentTaskFallsBackToDefaultWhenClassHasNoOverride() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.teachingClassStudentMapper = mock(TeachingClassStudentMapper.class);

        TeachingClassStudent membership = new TeachingClassStudent();
        membership.setTeachingClassId("class-1");
        when(service.teachingClassStudentMapper.selectActiveByStudentUserId("stu-1")).thenReturn(membership);

        TrainingTask defaultTask = storedTask("task-1", "new-product-survey");
        defaultTask.setTaskName("Default Name");
        when(service.trainingTaskMapper.selectByTaskKey("new-product-survey")).thenReturn(defaultTask);

        TrainingTask result = service.getStudentTaskByTaskKey("new-product-survey", "stu-1");

        assertEquals("Default Name", result.getTaskName());
    }

    @Test
    void teacherCannotEditClassCreatedByAnotherTeacher() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.schoolClassMapper = mock(SchoolClassMapper.class);

        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId("class-2");
        schoolClass.setClassType("TEACHING");
        schoolClass.setCreatedBy("teacher-a");
        when(service.schoolClassMapper.selectByPrimaryKey("class-2")).thenReturn(schoolClass);

        TrainingTask task = storedTask(null, "new-product-survey");

        assertThrows(IllegalArgumentException.class, () -> service.saveClassTask("class-2", "new-product-survey", task, "teacher-b"));
    }

    @Test
    void teacherCanReadAnotherTeachersTeachingClassInTheSameSchool() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.schoolClassMapper = mock(SchoolClassMapper.class);
        SchoolClass schoolClass = teachingClass("class-2", "teacher-a");
        schoolClass.setSchoolId("school-1");
        when(service.schoolClassMapper.selectByPrimaryKey("class-2")).thenReturn(schoolClass);

        JwtUser reader = new JwtUser();
        reader.setUserId("teacher-b");
        reader.setSchoolId("school-1");

        assertEquals(schoolClass, service.requireReadableTeachingClass("class-2", reader));
    }

    @Test
    void teacherCannotReadTeachingClassFromAnotherSchool() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.schoolClassMapper = mock(SchoolClassMapper.class);
        SchoolClass schoolClass = teachingClass("class-2", "teacher-a");
        schoolClass.setSchoolId("school-1");
        when(service.schoolClassMapper.selectByPrimaryKey("class-2")).thenReturn(schoolClass);

        JwtUser reader = new JwtUser();
        reader.setUserId("teacher-b");
        reader.setSchoolId("school-2");

        assertThrows(IllegalArgumentException.class,
                () -> service.requireReadableTeachingClass("class-2", reader));
    }

    @Test
    void restoreClassTaskDefaultDeletesOnlySelectedClassTaskCopy() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.schoolClassMapper = mock(SchoolClassMapper.class);
        when(service.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(teachingClass("class-1", "teacher-1"));

        service.restoreClassTaskDefault("class-1", "new-product-survey", "teacher-1");

        verify(service.trainingTaskClassConfigMapper)
                .deleteByTeachingClassAndTaskKey("class-1", "new-product-survey");
        verify(service.trainingTaskClassConfigMapper, never()).deleteByTeachingClass(anyString());
    }

    @Test
    void restoreClassTasksDefaultsDeletesOnlySelectedClassCopies() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.schoolClassMapper = mock(SchoolClassMapper.class);
        when(service.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(teachingClass("class-1", "teacher-1"));

        service.restoreClassTasksDefaults("class-1", "teacher-1");

        verify(service.trainingTaskClassConfigMapper).deleteByTeachingClass("class-1");
    }

    @Test
    void teacherCannotRestoreAnotherTeachersClass() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.schoolClassMapper = mock(SchoolClassMapper.class);
        when(service.schoolClassMapper.selectByPrimaryKey("class-2")).thenReturn(teachingClass("class-2", "teacher-a"));

        assertThrows(IllegalArgumentException.class,
                () -> service.restoreClassTasksDefaults("class-2", "teacher-b"));

        verifyNoInteractions(service.trainingTaskClassConfigMapper);
    }

    @Test
    void saveClassTaskInsertsNewOverrideWhenNoneExists() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.schoolClassMapper = mock(SchoolClassMapper.class);

        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId("class-1");
        schoolClass.setClassType("TEACHING");
        schoolClass.setCreatedBy("teacher-1");
        when(service.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(schoolClass);

        TrainingTask defaultTask = storedTask("task-1", "new-product-survey");
        defaultTask.setProjectName("Default Project");
        defaultTask.setSort(3);
        defaultTask.setKnowledge("Default Knowledge");
        when(service.trainingTaskMapper.selectByTaskKey("new-product-survey")).thenReturn(defaultTask);

        TrainingTask payload = storedTask(null, "new-product-survey");
        payload.setProjectName("Changed Project");
        payload.setTaskName("Class Name");
        payload.setKnowledge("Class Knowledge");
        payload.setMaterialName("Class Material");
        payload.setEnabled(Boolean.TRUE);

        service.saveClassTask("class-1", "new-product-survey", payload, "teacher-1");

        ArgumentCaptor<TrainingTaskClassConfig> captor = ArgumentCaptor.forClass(TrainingTaskClassConfig.class);
        verify(service.trainingTaskClassConfigMapper, times(24)).insertSelective(captor.capture());
        TrainingTaskClassConfig savedOverride = captor.getAllValues().stream()
                .filter(config -> "new-product-survey".equals(config.getTaskKey()))
                .filter(config -> "Class Name".equals(config.getTaskName()))
                .findFirst()
                .orElseThrow(AssertionError::new);
        assertEquals("class-1", savedOverride.getTeachingClassId());
        assertEquals("Default Project", savedOverride.getProjectName());
        assertEquals(Integer.valueOf(3), savedOverride.getSort());
        assertEquals("Class Knowledge", savedOverride.getKnowledge());
        assertEquals("Class Material", savedOverride.getMaterialName());
    }

    @Test
    void disabledClassOverrideMasksEnabledDefaultInStudentDetail() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.teachingClassStudentMapper = mock(TeachingClassStudentMapper.class);

        TeachingClassStudent membership = new TeachingClassStudent();
        membership.setTeachingClassId("class-1");
        when(service.teachingClassStudentMapper.selectActiveByStudentUserId("stu-1")).thenReturn(membership);

        TrainingTask defaultTask = storedTask("task-1", "new-product-survey");
        defaultTask.setEnabled(Boolean.TRUE);
        when(service.trainingTaskMapper.selectByTaskKey("new-product-survey")).thenReturn(defaultTask);

        TrainingTaskClassConfig override = overrideTask("config-1", "class-1", "new-product-survey");
        override.setEnabled(Boolean.FALSE);
        when(service.trainingTaskClassConfigMapper.selectByTeachingClassAndTaskKey("class-1", "new-product-survey")).thenReturn(override);

        TrainingTask result = service.getStudentTaskByTaskKey("new-product-survey", "stu-1");

        assertNull(result);
    }

    @Test
    void disabledClassOverrideMasksEnabledDefaultInStudentList() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.teachingClassStudentMapper = mock(TeachingClassStudentMapper.class);

        TeachingClassStudent membership = new TeachingClassStudent();
        membership.setTeachingClassId("class-1");
        when(service.teachingClassStudentMapper.selectActiveByStudentUserId("stu-1")).thenReturn(membership);

        TrainingTask defaultTask = storedTask("task-1", "new-product-survey");
        defaultTask.setEnabled(Boolean.TRUE);
        when(service.trainingTaskMapper.selectList(null, null, null)).thenReturn(Collections.singletonList(defaultTask));

        TrainingTaskClassConfig override = overrideTask("config-1", "class-1", "new-product-survey");
        override.setEnabled(Boolean.FALSE);
        when(service.trainingTaskClassConfigMapper.selectListByTeachingClass("class-1", null)).thenReturn(Collections.singletonList(override));

        List<TrainingTask> result = service.listForStudent("stu-1", true);

        assertEquals(0, result.size());
    }

    @Test
    void disabledClassOverrideMasksEnabledDefaultInTeacherClassList() {
        TrainingTaskServiceImpl service = new TrainingTaskServiceImpl();
        service.trainingTaskMapper = mock(TrainingTaskMapper.class);
        service.trainingTaskClassConfigMapper = mock(TrainingTaskClassConfigMapper.class);
        service.schoolClassMapper = mock(SchoolClassMapper.class);

        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId("class-1");
        schoolClass.setClassType("TEACHING");
        schoolClass.setCreatedBy("teacher-1");
        schoolClass.setSchoolId("school-1");
        when(service.schoolClassMapper.selectByPrimaryKey("class-1")).thenReturn(schoolClass);

        TrainingTask defaultTask = storedTask("task-1", "new-product-survey");
        defaultTask.setEnabled(Boolean.TRUE);
        when(service.trainingTaskMapper.selectList(null, null, null)).thenReturn(Collections.singletonList(defaultTask));

        TrainingTaskClassConfig override = overrideTask("config-1", "class-1", "new-product-survey");
        override.setEnabled(Boolean.FALSE);
        when(service.trainingTaskClassConfigMapper.selectListByTeachingClass("class-1", null)).thenReturn(Collections.singletonList(override));

        JwtUser teacher = new JwtUser();
        teacher.setUserId("teacher-1");
        teacher.setSchoolId("school-1");
        List<TrainingTask> result = service.listForTeachingClass("class-1", true, teacher);

        assertEquals(0, result.size());
    }

    private TrainingTask storedTask(String id, String taskKey) {
        TrainingTask task = new TrainingTask();
        task.setId(id);
        task.setTaskKey(taskKey);
        task.setProjectName("Foundation");
        task.setTaskName("Original Name");
        task.setSteps("[\"Step 1\",\"Step 2\",\"Step 3\",\"Step 4\"]");
        task.setSort(7);
        task.setEnabled(Boolean.TRUE);
        return task;
    }

    private SchoolClass teachingClass(String classId, String createdBy) {
        SchoolClass schoolClass = new SchoolClass();
        schoolClass.setSchoolClassId(classId);
        schoolClass.setClassType("TEACHING");
        schoolClass.setCreatedBy(createdBy);
        return schoolClass;
    }

    private TrainingTaskClassConfig overrideTask(String id, String teachingClassId, String taskKey) {
        TrainingTaskClassConfig config = new TrainingTaskClassConfig();
        config.setId(id);
        config.setTeachingClassId(teachingClassId);
        config.setTaskKey(taskKey);
        config.setProjectName("Foundation");
        config.setTaskName("Override Name");
        config.setSteps("[\"Step 1\",\"Step 2\",\"Step 3\",\"Step 4\"]");
        config.setSort(7);
        config.setEnabled(Boolean.TRUE);
        return config;
    }
}