Changes between Version 2 and Version 3 of appdevelopment

Timestamp:

02/04/26 21:54:59 (2 days ago)

Author:

231175

Comment:

--

appdevelopment

@@ -4 +4 @@
 
 === Креирање на курс ===
+{{{
+@Transactional
+    @Override
+    public CourseVersion createCourse(CourseDtoFull courseDtoFull) {
+        Language language = courseDtoFull.getLanguage();
 
+        Course course = buildCourse(courseDtoFull, language);
+
+        CourseVersion oldCourseVersion = courseVersionRepository
+                .findByActiveTrueAndCourse_Id(course.getId());
+
+        int newVersionNumber = 1;
+        if (oldCourseVersion != null) {
+            newVersionNumber = oldCourseVersion.getVersionNumber() + 1;
+            oldCourseVersion.setActive(false);
+            courseVersionRepository.save(oldCourseVersion);
+        }
+
+        CourseVersion courseVersion = CourseVersion.builder()
+                .versionNumber(newVersionNumber)
+                .active(true)
+                .creationDate(java.time.LocalDate.now())
+                .course(course)
+                .build();
+
+        List<CourseContent> contentList = courseDtoFull.getCourseContents().stream()
+                .map(content -> courseContentService.buildCourseContent(content, courseVersion, language))
+                .toList();
+
+        courseVersion.setCourseContents(contentList);
+
+        List<Tag> skillTags =  tagService.processRawTags(
+                courseDtoFull.getSkillsGained(), TagType.SKILL, language
+        );
+        List<Tag> topicTags = tagService.processRawTags(
+                courseDtoFull.getTopicsCovered(), TagType.TOPIC, language
+        );
+
+        List<Tag> tagList = new ArrayList<>(skillTags);
+        tagList.addAll(topicTags);
+
+        course.setTags(tagList);
+
+        return courseVersionRepository.save(courseVersion);
+    }
+
+    private Course buildCourse(CourseDtoFull courseDtoFull, Language language) {
+
+        int durationMinutes = courseDtoFull.getCourseContents().stream()
+                .flatMap(content -> content.getCourseLectures().stream())
+                .mapToInt(CourseLectureDtoFull::getDurationMinutes)
+                .sum();
+
+        Course course = Course.builder()
+                .imageUrl(courseDtoFull.getImageUrl())
+                .color(courseDtoFull.getColor())
+                .difficulty(courseDtoFull.getDifficulty())
+                .durationMinutes(durationMinutes)
+                .price(courseDtoFull.getPrice())
+                .build();
+
+        CourseTranslate courseTranslate = CourseTranslate.builder()
+                .language(language)
+                .titleShort(courseDtoFull.getTitleShort())
+                .title(courseDtoFull.getTitle())
+                .descriptionShort(courseDtoFull.getDescriptionShort())
+                .description(courseDtoFull.getDescription())
+                .descriptionLong(courseDtoFull.getDescriptionLong())
+                .whatWillBeLearned(courseDtoFull.getWhatWillBeLearned())
+                .course(course)
+                .build();
+
+        course.setTranslations(List.of(courseTranslate));
+        return course;
+    }
+}}}
+
+
+=== Преведување на постоечки курс ===
+{{{
+@Transactional
+    @Override
+    public Course translateCourse(CourseTranslateReq courseTranslateReq) {
+        validate.validateCourseExists(courseTranslateReq.getId());
+        validate.validateCourseTranslation(courseTranslateReq.getId(), courseTranslateReq.getLanguage());
+
+        CourseVersion courseVersion = courseVersionRepository.findByActiveTrueAndCourse_Id(courseTranslateReq.getId());
+        Course course = courseRepository.findById(courseTranslateReq.getId()).orElseThrow();
+        addCourseTranslation(course, courseTranslateReq);
+        translateContents(courseVersion, courseTranslateReq.getCourseContents(), courseTranslateReq.getLanguage());
+
+        tagService.processExistingTags(
+                courseTranslateReq.getSkillsGained(), TagType.SKILL, courseTranslateReq.getLanguage()
+        );
+        tagService.processExistingTags(
+                courseTranslateReq.getTopicsCovered(), TagType.TOPIC, courseTranslateReq.getLanguage()
+        );
+
+        return courseRepository.save(course);
+    }
+
+    private void addCourseTranslation(Course course, CourseTranslateReq dto) {
+        CourseTranslate translation = CourseTranslate.builder()
+                .language(dto.getLanguage())
+                .titleShort(dto.getTitleShort())
+                .title(dto.getTitle())
+                .descriptionShort(dto.getDescriptionShort())
+                .description(dto.getDescription())
+                .descriptionLong(dto.getDescriptionLong())
+                .whatWillBeLearned(dto.getWhatWillBeLearned())
+                .course(course)
+                .build();
+
+        course.getTranslations().add(translation);
+    }
+
+    private void translateContents(CourseVersion courseVersion, List<CourseContentTranslateReq> contentDtos, Language language) {
+        for (CourseContent content : courseVersion.getCourseContents()) {
+            CourseContentTranslateReq contentDto = contentDtos.stream()
+                    .filter(ct -> ct.getId().equals(content.getId()))
+                    .findFirst()
+                    .orElseThrow(() -> new RuntimeException(
+                            "Missing translation DTO for CourseContent id=" + content.getId()
+                    ));
+
+            addContentTranslation(content, contentDto, language);
+        }
+    }
+
+    private void addContentTranslation(CourseContent content, CourseContentTranslateReq contentDto, Language language) {
+        CourseContentTranslate contentTranslate = CourseContentTranslate.builder()
+                .title(contentDto.getTitle())
+                .language(language)
+                .courseContent(content)
+                .build();
+
+        content.getTranslations().add(contentTranslate);
+        translateLectures(content, contentDto.getCourseLectures(), language);
+    }
+
+    private void translateLectures(CourseContent content, List<CourseLectureTranslateReq> lectureDtos, Language language) {
+        for (CourseLecture lecture : content.getCourseLectures()) {
+            CourseLectureTranslateReq lectureDto = lectureDtos.stream()
+                    .filter(ld -> ld.getId().equals(lecture.getId()))
+                    .findFirst()
+                    .orElseThrow(() -> new RuntimeException(
+                            "Missing translation DTO for CourseLecture id=" + lecture.getId()
+                    ));
+
+            CourseLectureTranslate lectureTranslate = CourseLectureTranslate.builder()
+                    .language(language)
+                    .title(lectureDto.getTitle())
+                    .description(lectureDto.getDescription())
+                    .contentText(lectureDto.getContentText())
+                    .courseLecture(lecture)
+                    .build();
+
+            lecture.getTranslations().add(lectureTranslate);
+        }
+    }
+}}}
 
 == Pooling ==