Iris: Add lecture transcription storage

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java

@@ -34,6 +34,8 @@
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.faqingestionwebhook.PyrisWebhookFaqIngestionExecutionDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureDeletionExecutionDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureIngestionExecutionDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.transcriptionIngestion.PyrisWebhookTranscriptionDeletionExecutionDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.transcriptionIngestion.PyrisWebhookTranscriptionIngestionExecutionDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.LectureIngestionWebhookJob;
 import de.tum.cit.aet.artemis.iris.web.open.PublicPyrisStatusUpdateResource;
 
@@ -111,6 +113,47 @@ public void executePipeline(String feature, String variant, Object executionDTO,
         }
     }
 
+    /**
+     * Executes a webhook and send transcription to the webhook with the given variant
+     *
+     * @param variant      The variant of the feature to execute
+     * @param executionDTO The DTO sent as a body for the execution
+     */
+    public void executeTranscriptionAdditionWebhook(String variant, PyrisWebhookTranscriptionIngestionExecutionDTO executionDTO) {
+        var endpoint = "/api/v1/webhooks/transcriptions/" + variant;
+        try {
+            restTemplate.postForEntity(pyrisUrl + endpoint, objectMapper.valueToTree(executionDTO), Void.class);
+        }
+        catch (HttpStatusCodeException e) {
+            log.error("Failed to send transcription {} to Pyris: {}", executionDTO.lectureUnitId(), e.getMessage());
+            throw toIrisException(e);
+        }
+        catch (RestClientException | IllegalArgumentException e) {
+            log.error("Failed to send transcription {} to Pyris: {}", executionDTO.lectureUnitId(), e.getMessage());
+            throw new PyrisConnectorException("Could not fetch response from Pyris");
+        }
+    }
+
+    /**
+     * Executes a webhook and adds lecture transcriptions to the webhook with the given variant. This webhook deletes a lecture transcription in the Pyris system.
+     *
+     * @param executionDTO The DTO sent as a body for the execution
+     */
+    public void executeLectureTranscriptionDeletionWebhook(PyrisWebhookTranscriptionDeletionExecutionDTO executionDTO) {
+        var endpoint = "/api/v1/webhooks/transcriptions/delete";
+        try {
+            restTemplate.postForEntity(pyrisUrl + endpoint, objectMapper.valueToTree(executionDTO), Void.class);
+        }
+        catch (HttpStatusCodeException e) {
+            log.error("Failed to send lecture transcriptions to Pyris", e);
+            throw toIrisException(e);
+        }
+        catch (RestClientException | IllegalArgumentException e) {
+            log.error("Failed to send lecture transcriptions to Pyris", e);
+            throw new PyrisConnectorException("Could not fetch response from Pyris");
+        }
+    }
+
     /**
      * Executes a webhook and send lectures to the webhook with the given variant
      *

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java

@@ -25,6 +25,7 @@
 import de.tum.cit.aet.artemis.iris.service.pyris.job.FaqIngestionWebhookJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.LectureIngestionWebhookJob;
 import de.tum.cit.aet.artemis.iris.service.pyris.job.PyrisJob;
+import de.tum.cit.aet.artemis.iris.service.pyris.job.TranscriptionIngestionWebhookJob;
 
 /**
  * The PyrisJobService class is responsible for managing Pyris jobs in the Artemis system.
@@ -124,6 +125,21 @@ public String addFaqIngestionWebhookJob(long courseId, long faqId) {
         return token;
     }
 
+    /**
+     * Adds a new transcription ingestion webhook job to the job map with a timeout.
+     *
+     * @param courseId      the ID of the course associated with the webhook job
+     * @param lectureId     the ID of the lecture associated with the webhook job
+     * @param lectureUnitId the ID of the lecture Unit associated with the webhook job
+     * @return a unique token identifying the created webhook job
+     */
+    public String addTranscriptionIngestionWebhookJob(long courseId, long lectureId, long lectureUnitId) {
+        var token = generateJobIdToken();
+        var job = new TranscriptionIngestionWebhookJob(token, courseId, lectureId, lectureUnitId);
+        jobMap.put(token, job, ingestionJobTimeout, TimeUnit.SECONDS);
+        return token;
+    }
+
     /**
      * Remove a job from the job map.
      *

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java

@@ -35,10 +35,14 @@
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisLectureUnitWebhookDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureDeletionExecutionDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureIngestionExecutionDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.transcriptionIngestion.PyrisTranscriptionIngestionWebhookDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.transcriptionIngestion.PyrisWebhookTranscriptionDeletionExecutionDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.transcriptionIngestion.PyrisWebhookTranscriptionIngestionExecutionDTO;
 import de.tum.cit.aet.artemis.iris.service.settings.IrisSettingsService;
 import de.tum.cit.aet.artemis.lecture.domain.AttachmentType;
 import de.tum.cit.aet.artemis.lecture.domain.AttachmentUnit;
 import de.tum.cit.aet.artemis.lecture.domain.Lecture;
+import de.tum.cit.aet.artemis.lecture.domain.LectureTranscription;
 import de.tum.cit.aet.artemis.lecture.domain.LectureUnit;
 import de.tum.cit.aet.artemis.lecture.repository.LectureRepository;
 import de.tum.cit.aet.artemis.lecture.repository.LectureUnitRepository;
@@ -74,6 +78,85 @@ public PyrisWebhookService(PyrisConnectorService pyrisConnectorService, PyrisJob
         this.lectureRepository = lectureRepository;
     }
 
+    /**
+     * adds the transcription to the vector database in Pyris
+     *
+     * @param transcriptions The transcription that got Updated
+     * @param course         The course of the transcriptions
+     * @param lecture        The lecture of the transcriptions
+     * @param lectureUnit    The lecture unit of the transcriptions
+     * @return jobToken if the job was created else null
+     */
+    public String addTranscriptionsToPyrisDB(Set<LectureTranscription> transcriptions, Course course, Lecture lecture, LectureUnit lectureUnit) {
+        if (transcriptions == null || transcriptions.isEmpty()) {
+            throw new IllegalArgumentException("Transcriptions cannot be empty");
+        }
+
+        if (!lectureIngestionEnabled(course)) {
+            return null;
+        }
+
+        transcriptions.forEach(transcription -> {
+            if (transcription.getLecture() == null) {
+                throw new IllegalArgumentException("Transcription must be associated with a lecture");
+            }
+            else if (!transcription.getLecture().equals(lecture)) {
+                throw new IllegalArgumentException("All transcriptions must be associated with the same lecture");
+            }
+        });
+
+        List<PyrisTranscriptionIngestionWebhookDTO> pyrisTranscriptionIngestionWebhookDTOs = transcriptions.stream()
+                .map(transcription -> new PyrisTranscriptionIngestionWebhookDTO(transcription, lecture.getId(), lecture.getTitle(), course.getId(), course.getTitle(),
+                        course.getDescription()))
+                .toList();
+
+        return executeTranscriptionAdditionWebhook(pyrisTranscriptionIngestionWebhookDTOs, course, lecture, lectureUnit);
+    }
+
+    /**
+     * adds the lecture transcription into the vector database of Pyris
+     *
+     * @param toUpdateTranscriptions The transcription that are going to be Updated
+     * @return jobToken if the job was created
+     */
+    private String executeTranscriptionAdditionWebhook(List<PyrisTranscriptionIngestionWebhookDTO> toUpdateTranscriptions, Course course, Lecture lecture,
+            LectureUnit lectureUnit) {
+        String jobToken = pyrisJobService.addTranscriptionIngestionWebhookJob(course.getId(), lecture.getId(), lectureUnit.getId());
+        PyrisPipelineExecutionSettingsDTO settingsDTO = new PyrisPipelineExecutionSettingsDTO(jobToken, List.of(), artemisBaseUrl);
+        PyrisWebhookTranscriptionIngestionExecutionDTO executionDTO = new PyrisWebhookTranscriptionIngestionExecutionDTO(toUpdateTranscriptions, lectureUnit.getId(), settingsDTO,
+                List.of());
+        pyrisConnectorService.executeTranscriptionAdditionWebhook("fullIngestion", executionDTO);
+        return jobToken;
+    }
+
+    /**
+     * delete the lecture transcription in pyris
+     *
+     * @param lectureTranscription The lecture transcription that gets erased
+     * @return jobToken if the job was created
+     */
+    public String deleteLectureTranscription(LectureTranscription lectureTranscription) {
+        Lecture lecture = lectureTranscription.getLecture();
+        Course course = lecture.getCourse();
+        return executeLectureTranscriptionDeletionWebhook(
+                new PyrisTranscriptionIngestionWebhookDTO(lectureTranscription, lecture.getId(), lecture.getTitle(), course.getId(), course.getTitle(), course.getDescription()));
+    }
+
+    /**
+     * executes the faq deletion webhook to delete faq from the vector database on pyris
+     *
+     * @param toUpdateLectureTranscription The lecture transcription that got Updated as webhook DTO
+     * @return jobToken if the job was created else null
+     */
+    private String executeLectureTranscriptionDeletionWebhook(PyrisTranscriptionIngestionWebhookDTO toUpdateLectureTranscription) {
+        String jobToken = pyrisJobService.addTranscriptionIngestionWebhookJob(0, 0, 0);
+        PyrisPipelineExecutionSettingsDTO settingsDTO = new PyrisPipelineExecutionSettingsDTO(jobToken, List.of(), artemisBaseUrl);
+        PyrisWebhookTranscriptionDeletionExecutionDTO executionDTO = new PyrisWebhookTranscriptionDeletionExecutionDTO(toUpdateLectureTranscription, settingsDTO, List.of());
+        pyrisConnectorService.executeLectureTranscriptionDeletionWebhook(executionDTO);
+
+        return jobToken;
+    }
+
     private boolean lectureIngestionEnabled(Course course) {
         return irisSettingsService.getRawIrisSettingsFor(course).getIrisLectureIngestionSettings() != null
                 && irisSettingsService.getRawIrisSettingsFor(course).getIrisLectureIngestionSettings().isEnabled();

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/transcriptionIngestion/PyrisTranscriptionIngestionWebhookDTO.java

@@ -0,0 +1,16 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.transcriptionIngestion;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.lecture.domain.LectureTranscription;
+
+/**
+ * Represents a webhook data transfer object for lecture transcriptions on lecture unit level in the Pyris system.
+ * This DTO is used to encapsulate the information related to updates of lecture units,
+ * providing necessary details such as lecture and course identifiers, names, and descriptions.
+ */
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+
+public record PyrisTranscriptionIngestionWebhookDTO(LectureTranscription transcription, long lectureId, String lectureName, long courseId, String courseName,
+        String courseDescription) {
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/transcriptionIngestion/PyrisWebhookTranscriptionDeletionExecutionDTO.java

@@ -0,0 +1,13 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.transcriptionIngestion;
+
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.PyrisPipelineExecutionSettingsDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
+
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record PyrisWebhookTranscriptionDeletionExecutionDTO(PyrisTranscriptionIngestionWebhookDTO lectureTranscriptionDTO, PyrisPipelineExecutionSettingsDTO settings,
+        List<PyrisStageDTO> initalStages) {
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/transcriptionIngestion/PyrisWebhookTranscriptionIngestionExecutionDTO.java

@@ -0,0 +1,13 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.transcriptionIngestion;
+
+import java.util.List;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.PyrisPipelineExecutionSettingsDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
+
+@JsonInclude(JsonInclude.Include.NON_EMPTY)
+public record PyrisWebhookTranscriptionIngestionExecutionDTO(List<PyrisTranscriptionIngestionWebhookDTO> transcriptions, Long lectureUnitId,
+        PyrisPipelineExecutionSettingsDTO settings, List<PyrisStageDTO> initialStages) {
+}

src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/TranscriptionIngestionWebhookJob.java

@@ -0,0 +1,21 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.job;
+
+import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.exercise.domain.Exercise;
+
+/**
+ * An implementation of a PyrisJob for Transcription Ingestion in Pyris.
+ * This job is used to reference the details of then Ingestion when Pyris sends a status update.
+ */
+public record TranscriptionIngestionWebhookJob(String jobId, long courseId, long lectureId, long lectureUnitId) implements PyrisJob {
+
+    @Override
+    public boolean canAccess(Course course) {
+        return false;
+    }
+
+    @Override
+    public boolean canAccess(Exercise exercise) {
+        return false;
+    }
+}

src/main/java/de/tum/cit/aet/artemis/lecture/domain/Lecture.java

@@ -60,6 +60,11 @@ public class Lecture extends DomainObject {
     @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
     private List<LectureUnit> lectureUnits = new ArrayList<>();
 
+    @OneToMany(mappedBy = "lecture", cascade = CascadeType.ALL, orphanRemoval = true)
+    @JsonIgnoreProperties("lecture")
+    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+    private Set<LectureTranscription> lectureTranscriptions = new HashSet<>();
+
     @OneToMany(mappedBy = "lecture", cascade = CascadeType.REMOVE, orphanRemoval = true)
     @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
     @JsonIncludeProperties({ "id" })
@@ -141,6 +146,19 @@ public void addLectureUnit(LectureUnit lectureUnit) {
         lectureUnit.setLecture(this);
     }
 
+    public Set<LectureTranscription> getLectureTranscriptions() {
+        return lectureTranscriptions;
+    }
+
+    public void setTranscriptions(Set<LectureTranscription> lectureTranscriptions) {
+        this.lectureTranscriptions = lectureTranscriptions;
+    }
+
+    public void addTranscription(LectureTranscription lectureTranscription) {
+        this.lectureTranscriptions.add(lectureTranscription);
+        lectureTranscription.setLecture(this);
+    }
+
     public Set<Post> getPosts() {
         return posts;
     }

src/main/java/de/tum/cit/aet/artemis/lecture/domain/LectureTranscription.java

@@ -0,0 +1,93 @@
+package de.tum.cit.aet.artemis.lecture.domain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import jakarta.persistence.CascadeType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.FetchType;
+import jakarta.persistence.JoinColumn;
+import jakarta.persistence.ManyToOne;
+import jakarta.persistence.OneToMany;
+import jakarta.persistence.OrderBy;
+import jakarta.persistence.Table;
+import jakarta.validation.constraints.Size;
+
+import org.hibernate.annotations.Cache;
+import org.hibernate.annotations.CacheConcurrencyStrategy;
+
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+import de.tum.cit.aet.artemis.core.domain.DomainObject;
+
+@Entity
+@Table(name = "lecture_transcription")
+public class LectureTranscription extends DomainObject {
+
+    @ManyToOne
+    @JoinColumn(name = "lecture_id")
+    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+    @JsonIgnore
+    private Lecture lecture;
+
+    @Size(min = 2, max = 2, message = "Language must be exactly 2 characters long")
+    private String language;
+
+    @OneToMany(cascade = CascadeType.ALL, fetch = FetchType.LAZY, orphanRemoval = true)
+    @OrderBy("startTime asc")
+    @JoinColumn(name = "transcription_id")
+    private List<LectureTranscriptionSegment> segments = new ArrayList<>();
+
+    @ManyToOne
+    @JoinColumn(name = "lecture_unit_id")
+    @Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE)
+    @JsonIgnore
+    private LectureUnit lectureUnit;
+
+    public LectureTranscription() {
+    }
+
+    public LectureTranscription(Lecture lecture, String language, List<LectureTranscriptionSegment> segments, LectureUnit lectureUnit) {
+        this.lecture = lecture;
+        this.language = language;
+        this.segments = segments;
+        this.lectureUnit = lectureUnit;
+    }
+
+    public Lecture getLecture() {
+        return lecture;
+    }
+
+    public void setLecture(Lecture lecture) {
+        this.lecture = lecture;
+    }
+
+    public String getLanguage() {
+        return language;
+    }
+
+    public void setLanguage(String language) {
+        this.language = language;
+    }
+
+    public List<LectureTranscriptionSegment> getSegments() {
+        return segments;
+    }
+
+    public void setSegments(List<LectureTranscriptionSegment> segments) {
+        this.segments = segments;
+    }
+
+    public LectureUnit getLectureUnit() {
+        return lectureUnit;
+    }
+
+    public void setLectureUnit(LectureUnit lectureUnit) {
+        this.lectureUnit = lectureUnit;
+    }
+
+    @Override
+    public String toString() {
+        return "Transcription [language=" + language + ", segments=" + segments + "]";
+    }
+}