From 9270bc0553aed216d7d81cfedb8fde385843ccb0 Mon Sep 17 00:00:00 2001
From: Yassine Souissi <74144843+yassinsws@users.noreply.github.com>
Date: Fri, 29 Nov 2024 22:53:08 +0100
Subject: [PATCH] Iris: Display ingestion state for lecture slide upload 
 (#9090)

---
 .../Artemis__Server__LocalVC___Jenkins_.xml   |   2 +-
 .../Artemis__Server__LocalVC___LocalCI_.xml   |   4 +-
 .../aet/artemis/iris/dto/IngestionState.java  |   5 +
 .../iris/dto/IngestionStateResponseDTO.java   |   4 +
 .../service/pyris/PyrisConnectorService.java  |  67 +++++++-
 .../iris/service/pyris/PyrisJobService.java   |  17 +-
 .../pyris/PyrisStatusUpdateService.java       |   4 +-
 .../service/pyris/PyrisWebhookService.java    | 157 +++++++++++++-----
 .../PyrisLectureIngestionStatusUpdateDTO.java |   2 +-
 .../PyrisLectureUnitWebhookDTO.java           |   4 +-
 ...risWebhookLectureDeletionExecutionDTO.java |  13 ++
 ...isWebhookLectureIngestionExecutionDTO.java |   3 +-
 .../pyris/job/IngestionWebhookJob.java        |   2 +-
 .../aet/artemis/iris/web/IrisResource.java    |  82 ++++++++-
 .../open/PublicPyrisStatusUpdateResource.java |   1 -
 .../lecture/repository/LectureRepository.java |  20 +++
 .../repository/LectureUnitRepository.java     |  10 ++
 .../lecture/service/LectureService.java       |   8 +-
 .../lecture/service/LectureUnitService.java   |  30 ++++
 .../artemis/lecture/web/LectureResource.java  |  14 +-
 .../lecture/web/LectureUnitResource.java      |  30 +++-
 .../scaparser/format/sarif/Result.java        |   4 +-
 .../lecture-unit/attachmentUnit.model.ts      |   9 +
 src/main/webapp/app/entities/lecture.model.ts |   2 +
 .../app/lecture/lecture-detail.component.ts   |   8 +-
 .../lecture-unit-management.component.html    |  60 +++++--
 .../lecture-unit-management.component.ts      | 101 ++++++++++-
 .../lectureUnit.service.ts                    |  26 ++-
 .../webapp/app/lecture/lecture.component.html |  30 ++++
 .../webapp/app/lecture/lecture.component.ts   |  48 +++++-
 .../webapp/app/lecture/lecture.service.ts     |  13 +-
 .../app/overview/course-overview.service.ts   |   2 +-
 src/main/webapp/i18n/de/iris.json             |  19 +++
 src/main/webapp/i18n/de/lecture.json          |   1 +
 src/main/webapp/i18n/en/iris.json             |  19 +++
 src/main/webapp/i18n/en/lecture.json          |   1 +
 .../connector/IrisRequestMockProvider.java    |  18 ++
 .../iris/PyrisConnectorServiceTest.java       |  15 +-
 .../iris/PyrisLectureIngestionTest.java       | 149 +++++++++--------
 .../lecture-unit-management.component.spec.ts |  88 +++++++++-
 .../lecture-unit/lecture-unit.service.spec.ts |  42 ++++-
 .../lecture/lecture-detail.component.spec.ts  |   2 +-
 .../lecture/lecture.component.spec.ts         |  57 ++++---
 .../spec/service/lecture.service.spec.ts      |  19 +++
 44 files changed, 997 insertions(+), 215 deletions(-)
 create mode 100644 src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionState.java
 create mode 100644 src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionStateResponseDTO.java
 create mode 100644 src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureDeletionExecutionDTO.java

diff --git a/.idea/runConfigurations/Artemis__Server__LocalVC___Jenkins_.xml b/.idea/runConfigurations/Artemis__Server__LocalVC___Jenkins_.xml
index 217477ace79d..2eae7040817e 100644
--- a/.idea/runConfigurations/Artemis__Server__LocalVC___Jenkins_.xml
+++ b/.idea/runConfigurations/Artemis__Server__LocalVC___Jenkins_.xml
@@ -9,4 +9,4 @@
       <option name="Gradle.BeforeRunTask" enabled="false" tasks="build" externalProjectPath="$PROJECT_DIR$" vmOptions="" scriptParameters="-x webapp -x test -x jacocoTestCoverageVerification -x spotlessCheck -x checkstyleMain -x checkstyleTest" />
     </method>
   </configuration>
-</component>
\ No newline at end of file
+</component>
diff --git a/.idea/runConfigurations/Artemis__Server__LocalVC___LocalCI_.xml b/.idea/runConfigurations/Artemis__Server__LocalVC___LocalCI_.xml
index 2323d3d5ca3b..9135ec4a2fd2 100644
--- a/.idea/runConfigurations/Artemis__Server__LocalVC___LocalCI_.xml
+++ b/.idea/runConfigurations/Artemis__Server__LocalVC___LocalCI_.xml
@@ -1,7 +1,7 @@
 <component name="ProjectRunConfigurationManager">
   <configuration default="false" name="Artemis (Server, LocalVC &amp; LocalCI)" type="SpringBootApplicationConfigurationType" factoryName="Spring Boot">
-    <option name="ACTIVE_PROFILES" value="dev,localci,localvc,artemis,scheduling,buildagent,core,ldap-only,local" />
-    <option name="ALTERNATIVE_JRE_PATH" value="17" />
+      <option name="ACTIVE_PROFILES" value="dev,localci,localvc,artemis,scheduling,buildagent,core,ldap-only,local" />
+      <option name="ALTERNATIVE_JRE_PATH" value="17" />
     <module name="Artemis.main" />
     <option name="SHORTEN_COMMAND_LINE" value="MANIFEST" />
     <option name="SPRING_BOOT_MAIN_CLASS" value="de.tum.cit.aet.artemis.ArtemisApp" />
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionState.java b/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionState.java
new file mode 100644
index 000000000000..6ed226ce4400
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionState.java
@@ -0,0 +1,5 @@
+package de.tum.cit.aet.artemis.iris.dto;
+
+public enum IngestionState {
+    NOT_STARTED, IN_PROGRESS, PARTIALLY_INGESTED, DONE, ERROR
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionStateResponseDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionStateResponseDTO.java
new file mode 100644
index 000000000000..54d5a04bd3cf
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/dto/IngestionStateResponseDTO.java
@@ -0,0 +1,4 @@
+package de.tum.cit.aet.artemis.iris.dto;
+
+public record IngestionStateResponseDTO(IngestionState state) {
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java
index f41de6b6c97d..911428b5b176 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisConnectorService.java
@@ -2,6 +2,8 @@
 
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_IRIS;
 
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
 import java.util.Arrays;
 import java.util.List;
 
@@ -20,11 +22,15 @@
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 import de.tum.cit.aet.artemis.iris.domain.settings.IrisSubSettingsType;
+import de.tum.cit.aet.artemis.iris.dto.IngestionState;
+import de.tum.cit.aet.artemis.iris.dto.IngestionStateResponseDTO;
 import de.tum.cit.aet.artemis.iris.exception.IrisException;
 import de.tum.cit.aet.artemis.iris.exception.IrisForbiddenException;
 import de.tum.cit.aet.artemis.iris.exception.IrisInternalPyrisErrorException;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.PyrisVariantDTO;
+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.job.IngestionWebhookJob;
 import de.tum.cit.aet.artemis.iris.web.open.PublicPyrisStatusUpdateResource;
 
 /**
@@ -42,12 +48,19 @@ public class PyrisConnectorService {
 
     private final ObjectMapper objectMapper;
 
+    private final PyrisJobService pyrisJobService;
+
+    @Value("${server.url}")
+    private String artemisBaseUrl;
+
     @Value("${artemis.iris.url}")
     private String pyrisUrl;
 
-    public PyrisConnectorService(@Qualifier("pyrisRestTemplate") RestTemplate restTemplate, MappingJackson2HttpMessageConverter springMvcJacksonConverter) {
+    public PyrisConnectorService(@Qualifier("pyrisRestTemplate") RestTemplate restTemplate, MappingJackson2HttpMessageConverter springMvcJacksonConverter,
+            PyrisJobService pyrisJobService) {
         this.restTemplate = restTemplate;
         this.objectMapper = springMvcJacksonConverter.getObjectMapper();
+        this.pyrisJobService = pyrisJobService;
     }
 
     /**
@@ -97,15 +110,63 @@ public void executePipeline(String feature, String variant, Object executionDTO)
      * @param variant      The variant of the feature to execute
      * @param executionDTO The DTO sent as a body for the execution
      */
-    public void executeLectureWebhook(String variant, PyrisWebhookLectureIngestionExecutionDTO executionDTO) {
+    public void executeLectureAddtionWebhook(String variant, PyrisWebhookLectureIngestionExecutionDTO executionDTO) {
         var endpoint = "/api/v1/webhooks/lectures/" + variant;
         try {
             restTemplate.postForEntity(pyrisUrl + endpoint, objectMapper.valueToTree(executionDTO), Void.class);
         }
+        catch (HttpStatusCodeException e) {
+            log.error("Failed to send lecture unit {} to Pyris: {}", executionDTO.pyrisLectureUnit().lectureUnitId(), e.getMessage());
+            throw toIrisException(e);
+        }
+        catch (RestClientException | IllegalArgumentException e) {
+            log.error("Failed to send lecture unit {} to Pyris: {}", executionDTO.pyrisLectureUnit().lectureUnitId(), e.getMessage());
+            throw new PyrisConnectorException("Could not fetch response from Pyris");
+        }
+    }
+
+    /**
+     * Retrieves the ingestion state of the lecture unit specified by retrieving the ingestion state from the vector database in Pyris.
+     *
+     * @param courseId      id of the course
+     * @param lectureId     id of the lecture
+     * @param lectureUnitId id of the lectureUnit to check in the Pyris vector database
+     * @return The ingestion state of the lecture Unit
+     *
+     */
+    IngestionState getLectureUnitIngestionState(long courseId, long lectureId, long lectureUnitId) {
+        try {
+            String encodedBaseUrl = URLEncoder.encode(artemisBaseUrl, StandardCharsets.UTF_8);
+            String url = pyrisUrl + "/api/v1/courses/" + courseId + "/lectures/" + lectureId + "/lectureUnits/" + lectureUnitId + "/ingestion-state?base_url=" + encodedBaseUrl;
+            IngestionStateResponseDTO response = restTemplate.getForObject(url, IngestionStateResponseDTO.class);
+            IngestionState state = response.state();
+            if (state != IngestionState.DONE) {
+                if (pyrisJobService.currentJobs().stream().filter(job -> job instanceof IngestionWebhookJob).map(job -> (IngestionWebhookJob) job)
+                        .anyMatch(ingestionJob -> ingestionJob.courseId() == courseId && ingestionJob.lectureId() == lectureId && ingestionJob.lectureUnitId() == lectureUnitId)) {
+                    return IngestionState.IN_PROGRESS;
+                }
+            }
+            return state;
+        }
+        catch (RestClientException | IllegalArgumentException e) {
+            log.error("Error fetching ingestion state for lecture {}, lecture unit {}", lectureId, lectureUnitId, e);
+            throw new PyrisConnectorException("Error fetching ingestion state for lecture unit" + lectureUnitId);
+        }
+    }
+
+    /**
+     * Executes a webhook and send lectures to the webhook with the given variant
+     *
+     * @param executionDTO The DTO sent as a body for the execution
+     */
+    public void executeLectureDeletionWebhook(PyrisWebhookLectureDeletionExecutionDTO executionDTO) {
+        var endpoint = "/api/v1/webhooks/lectures/delete";
+        try {
+            restTemplate.postForEntity(pyrisUrl + endpoint, objectMapper.valueToTree(executionDTO), Void.class);
+        }
         catch (HttpStatusCodeException e) {
             log.error("Failed to send lectures to Pyris", e);
             throw toIrisException(e);
-            // TODO : add error ingestion UI.
         }
         catch (RestClientException | IllegalArgumentException e) {
             log.error("Failed to send lectures to Pyris", e);
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java
index 16e8969bc463..46c0dd7547cd 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisJobService.java
@@ -3,6 +3,7 @@
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_IRIS;
 
 import java.security.SecureRandom;
+import java.util.Collection;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Function;
 
@@ -93,11 +94,14 @@ public String addCourseChatJob(Long courseId, Long sessionId) {
     /**
      * Adds a new 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 addIngestionWebhookJob() {
+    public String addIngestionWebhookJob(long courseId, long lectureId, long lectureUnitId) {
         var token = generateJobIdToken();
-        var job = new IngestionWebhookJob(token);
+        var job = new IngestionWebhookJob(token, courseId, lectureId, lectureUnitId);
         long timeoutWebhookJob = 60;
         TimeUnit unitWebhookJob = TimeUnit.MINUTES;
         jobMap.put(token, job, timeoutWebhookJob, unitWebhookJob);
@@ -122,6 +126,15 @@ public void updateJob(PyrisJob job) {
         jobMap.put(job.jobId(), job);
     }
 
+    /**
+     * Get all current jobs.
+     *
+     * @return the all current jobs
+     */
+    public Collection<PyrisJob> currentJobs() {
+        return jobMap.values();
+    }
+
     /**
      * Get the job of a token.
      *
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java
index cdd398e5c683..ad1a63e60c58 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisStatusUpdateService.java
@@ -126,14 +126,12 @@ private void removeJobIfTerminatedElseUpdate(List<PyrisStageDTO> stages, PyrisJo
     }
 
     /**
-     * Handles the status update of a lecture ingestion job and logs the results for now => will change later
-     * TODO: Update this method to handle changes beyond logging
+     * Handles the status update of a lecture ingestion job.
      *
      * @param job          the job that is updated
      * @param statusUpdate the status update
      */
     public void handleStatusUpdate(IngestionWebhookJob job, PyrisLectureIngestionStatusUpdateDTO statusUpdate) {
-        statusUpdate.stages().forEach(stage -> log.info(stage.name() + ":" + stage.message()));
         removeJobIfTerminatedElseUpdate(statusUpdate.stages(), job);
     }
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java
index 03f58ad5ba14..2138b8789b0b 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/PyrisWebhookService.java
@@ -9,6 +9,9 @@
 import java.util.ArrayList;
 import java.util.Base64;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -17,16 +20,23 @@
 import org.springframework.stereotype.Service;
 
 import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.domain.DomainObject;
 import de.tum.cit.aet.artemis.core.service.FilePathService;
 import de.tum.cit.aet.artemis.iris.domain.settings.IrisCourseSettings;
+import de.tum.cit.aet.artemis.iris.dto.IngestionState;
 import de.tum.cit.aet.artemis.iris.exception.IrisInternalPyrisErrorException;
 import de.tum.cit.aet.artemis.iris.repository.IrisSettingsRepository;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.PyrisPipelineExecutionSettingsDTO;
 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.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.LectureUnit;
+import de.tum.cit.aet.artemis.lecture.repository.LectureRepository;
+import de.tum.cit.aet.artemis.lecture.repository.LectureUnitRepository;
 
 @Service
 @Profile(PROFILE_IRIS)
@@ -42,15 +52,21 @@ public class PyrisWebhookService {
 
     private final IrisSettingsRepository irisSettingsRepository;
 
+    private final LectureUnitRepository lectureUnitRepository;
+
+    private final LectureRepository lectureRepository;
+
     @Value("${server.url}")
     private String artemisBaseUrl;
 
     public PyrisWebhookService(PyrisConnectorService pyrisConnectorService, PyrisJobService pyrisJobService, IrisSettingsService irisSettingsService,
-            IrisSettingsRepository irisSettingsRepository) {
+            IrisSettingsRepository irisSettingsRepository, LectureUnitRepository lectureUnitRepository, LectureRepository lectureRepository) {
         this.pyrisConnectorService = pyrisConnectorService;
         this.pyrisJobService = pyrisJobService;
         this.irisSettingsService = irisSettingsService;
         this.irisSettingsRepository = irisSettingsRepository;
+        this.lectureUnitRepository = lectureUnitRepository;
+        this.lectureRepository = lectureRepository;
     }
 
     private boolean lectureIngestionEnabled(Course course) {
@@ -78,15 +94,15 @@ private PyrisLectureUnitWebhookDTO processAttachmentForUpdate(AttachmentUnit att
         String courseTitle = attachmentUnit.getLecture().getCourse().getTitle();
         String courseDescription = attachmentUnit.getLecture().getCourse().getDescription() == null ? "" : attachmentUnit.getLecture().getCourse().getDescription();
         String base64EncodedPdf = attachmentToBase64(attachmentUnit);
-        return new PyrisLectureUnitWebhookDTO(true, artemisBaseUrl, base64EncodedPdf, lectureUnitId, lectureUnitName, lectureId, lectureTitle, courseId, courseTitle,
-                courseDescription);
+        lectureUnitRepository.save(attachmentUnit);
+        return new PyrisLectureUnitWebhookDTO(base64EncodedPdf, lectureUnitId, lectureUnitName, lectureId, lectureTitle, courseId, courseTitle, courseDescription);
     }
 
     private PyrisLectureUnitWebhookDTO processAttachmentForDeletion(AttachmentUnit attachmentUnit) {
         Long lectureUnitId = attachmentUnit.getId();
         Long lectureId = attachmentUnit.getLecture().getId();
         Long courseId = attachmentUnit.getLecture().getCourse().getId();
-        return new PyrisLectureUnitWebhookDTO(false, artemisBaseUrl, "", lectureUnitId, "", lectureId, "", courseId, "", "");
+        return new PyrisLectureUnitWebhookDTO("", lectureUnitId, "", lectureId, "", courseId, "", "");
     }
 
     /**
@@ -94,15 +110,15 @@ private PyrisLectureUnitWebhookDTO processAttachmentForDeletion(AttachmentUnit a
      *
      * @param courseId           Id of the course where the attachment is added
      * @param newAttachmentUnits the new attachment Units to be sent to pyris for ingestion
-     * @return true if the units were sent to pyris
      */
-    public boolean autoUpdateAttachmentUnitsInPyris(Long courseId, List<AttachmentUnit> newAttachmentUnits) {
+    public void autoUpdateAttachmentUnitsInPyris(Long courseId, List<AttachmentUnit> newAttachmentUnits) {
         IrisCourseSettings courseSettings = irisSettingsRepository.findCourseSettings(courseId).isPresent() ? irisSettingsRepository.findCourseSettings(courseId).get() : null;
         if (courseSettings != null && courseSettings.getIrisLectureIngestionSettings() != null && courseSettings.getIrisLectureIngestionSettings().isEnabled()
                 && courseSettings.getIrisLectureIngestionSettings().getAutoIngestOnLectureAttachmentUpload()) {
-            return addLectureUnitsToPyrisDB(newAttachmentUnits) != null;
+            for (AttachmentUnit attachmentUnit : newAttachmentUnits) {
+                addLectureUnitToPyrisDB(attachmentUnit);
+            }
         }
-        return false;
     }
 
     /**
@@ -112,44 +128,29 @@ public boolean autoUpdateAttachmentUnitsInPyris(Long courseId, List<AttachmentUn
      * @return jobToken if the job was created
      */
     public String deleteLectureFromPyrisDB(List<AttachmentUnit> attachmentUnits) {
-        try {
-            List<PyrisLectureUnitWebhookDTO> toUpdateAttachmentUnits = new ArrayList<>();
-            attachmentUnits.stream().filter(unit -> unit.getAttachment().getAttachmentType() == AttachmentType.FILE && unit.getAttachment().getLink().endsWith(".pdf"))
-                    .forEach(unit -> {
-                        toUpdateAttachmentUnits.add(processAttachmentForDeletion(unit));
-                    });
-            if (!toUpdateAttachmentUnits.isEmpty()) {
-                return executeLectureWebhook(toUpdateAttachmentUnits);
-            }
-        }
-        catch (Exception e) {
-            log.error(e.getMessage());
+        List<PyrisLectureUnitWebhookDTO> toUpdateAttachmentUnits = new ArrayList<>();
+        attachmentUnits.stream().filter(unit -> unit.getAttachment().getAttachmentType() == AttachmentType.FILE && unit.getAttachment().getLink().endsWith(".pdf"))
+                .forEach(unit -> {
+                    toUpdateAttachmentUnits.add(processAttachmentForDeletion(unit));
+                });
+        if (!toUpdateAttachmentUnits.isEmpty()) {
+            return executeLectureDeletionWebhook(toUpdateAttachmentUnits);
         }
         return null;
     }
 
     /**
-     * adds the lectures to the vector database on pyris
+     * adds the lectures to the vector database in Pyris
      *
-     * @param attachmentUnits The attachmentUnit that got Updated / erased
-     * @return jobToken if the job was created
+     * @param attachmentUnit The attachmentUnit that got Updated
+     * @return jobToken if the job was created else null
      */
-    public String addLectureUnitsToPyrisDB(List<AttachmentUnit> attachmentUnits) {
-        if (!lectureIngestionEnabled(attachmentUnits.getFirst().getLecture().getCourse())) {
-            return null;
-        }
-        try {
-            List<PyrisLectureUnitWebhookDTO> toUpdateAttachmentUnits = new ArrayList<>();
-            attachmentUnits.stream().filter(unit -> unit.getAttachment().getAttachmentType() == AttachmentType.FILE && unit.getAttachment().getLink().endsWith(".pdf"))
-                    .forEach(unit -> {
-                        toUpdateAttachmentUnits.add(processAttachmentForUpdate(unit));
-                    });
-            if (!toUpdateAttachmentUnits.isEmpty()) {
-                return executeLectureWebhook(toUpdateAttachmentUnits);
+    public String addLectureUnitToPyrisDB(AttachmentUnit attachmentUnit) {
+        if (lectureIngestionEnabled(attachmentUnit.getLecture().getCourse())) {
+            if (attachmentUnit.getAttachment().getAttachmentType() == AttachmentType.FILE && attachmentUnit.getAttachment().getLink().endsWith(".pdf")) {
+                return executeLectureAdditionWebhook(processAttachmentForUpdate(attachmentUnit));
             }
-        }
-        catch (Exception e) {
-            log.error(e.getMessage());
+            log.error("Attachment {} is not a file or is not of type pdf thus it will not be sent to Pyris", attachmentUnit.getId());
         }
         return null;
     }
@@ -157,15 +158,85 @@ public String addLectureUnitsToPyrisDB(List<AttachmentUnit> attachmentUnits) {
     /**
      * executes executeLectureWebhook add or delete lectures from to the vector database on pyris
      *
-     * @param toUpdateAttachmentUnits The attachmentUnit that are goin to be Updated / deleted
+     * @param toUpdateAttachmentUnits The attachmentUnit that are goin to be deleted
      * @return jobToken if the job was created
      */
-    private String executeLectureWebhook(List<PyrisLectureUnitWebhookDTO> toUpdateAttachmentUnits) {
-        String jobToken = pyrisJobService.addIngestionWebhookJob();
+    private String executeLectureDeletionWebhook(List<PyrisLectureUnitWebhookDTO> toUpdateAttachmentUnits) {
+        String jobToken = pyrisJobService.addIngestionWebhookJob(0, 0, 0);
         PyrisPipelineExecutionSettingsDTO settingsDTO = new PyrisPipelineExecutionSettingsDTO(jobToken, List.of(), artemisBaseUrl);
-        PyrisWebhookLectureIngestionExecutionDTO executionDTO = new PyrisWebhookLectureIngestionExecutionDTO(toUpdateAttachmentUnits, settingsDTO, List.of());
-        pyrisConnectorService.executeLectureWebhook("fullIngestion", executionDTO);
+        PyrisWebhookLectureDeletionExecutionDTO executionDTO = new PyrisWebhookLectureDeletionExecutionDTO(toUpdateAttachmentUnits, settingsDTO, List.of());
+        pyrisConnectorService.executeLectureDeletionWebhook(executionDTO);
         return jobToken;
     }
 
+    /**
+     * executes executeLectureAdditionWebhook add lecture from to the vector database on pyris
+     *
+     * @param toUpdateAttachmentUnit The attachmentUnit that are going to be Updated
+     * @return jobToken if the job was created
+     */
+    private String executeLectureAdditionWebhook(PyrisLectureUnitWebhookDTO toUpdateAttachmentUnit) {
+        String jobToken = pyrisJobService.addIngestionWebhookJob(toUpdateAttachmentUnit.courseId(), toUpdateAttachmentUnit.lectureId(), toUpdateAttachmentUnit.lectureUnitId());
+        PyrisPipelineExecutionSettingsDTO settingsDTO = new PyrisPipelineExecutionSettingsDTO(jobToken, List.of(), artemisBaseUrl);
+        PyrisWebhookLectureIngestionExecutionDTO executionDTO = new PyrisWebhookLectureIngestionExecutionDTO(toUpdateAttachmentUnit, settingsDTO, List.of());
+        pyrisConnectorService.executeLectureAddtionWebhook("fullIngestion", executionDTO);
+        return jobToken;
+    }
+
+    /**
+     * uses getLectureUnitIngestionState for all lecture units and then determines the IngestionState of the lecture
+     *
+     * @param courseId id of the course
+     * @return The ingestion state of the lecture
+     *
+     */
+    public Map<Long, IngestionState> getLecturesIngestionState(long courseId) {
+        Set<Lecture> lectures = lectureRepository.findAllByCourseId(courseId);
+        return lectures.stream().collect(Collectors.toMap(DomainObject::getId, lecture -> getLectureIngestionState(courseId, lecture.getId())));
+
+    }
+
+    /**
+     * uses getLectureUnitIngestionState for all lecture units and then determines the IngestionState of the lecture
+     *
+     * @param courseId  id of the course
+     * @param lectureId id of the lecture
+     * @return The ingestion state of the lecture
+     *
+     */
+    private IngestionState getLectureIngestionState(long courseId, long lectureId) {
+        Map<Long, IngestionState> states = getLectureUnitsIngestionState(courseId, lectureId);
+
+        if (states.values().stream().allMatch(state -> state == IngestionState.DONE)) {
+            return IngestionState.DONE;
+        }
+
+        if (states.values().stream().allMatch(state -> state == IngestionState.NOT_STARTED)) {
+            return IngestionState.NOT_STARTED;
+        }
+
+        if (states.values().stream().allMatch(state -> state == IngestionState.ERROR)) {
+            return IngestionState.ERROR;
+        }
+
+        if (states.containsValue(IngestionState.DONE) || states.containsValue(IngestionState.IN_PROGRESS)) {
+            return IngestionState.PARTIALLY_INGESTED;
+        }
+
+        return IngestionState.NOT_STARTED;
+    }
+
+    /**
+     * uses send an api call to get all the ingestion states of the lecture units of one lecture in Pyris
+     *
+     * @param courseId  id of the course
+     * @param lectureId id of the lecture
+     * @return The ingestion state of the lecture Unit
+     */
+    public Map<Long, IngestionState> getLectureUnitsIngestionState(long courseId, long lectureId) {
+        List<LectureUnit> lectureunits = lectureRepository.findByIdWithLectureUnitsElseThrow(lectureId).getLectureUnits();
+        return lectureunits.stream().filter(lectureUnit -> lectureUnit instanceof AttachmentUnit)
+                .collect(Collectors.toMap(DomainObject::getId, unit -> pyrisConnectorService.getLectureUnitIngestionState(courseId, lectureId, unit.getId())));
+    }
+
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureIngestionStatusUpdateDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureIngestionStatusUpdateDTO.java
index b49aafefac79..56582b2e1ac2 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureIngestionStatusUpdateDTO.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureIngestionStatusUpdateDTO.java
@@ -7,5 +7,5 @@
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
 
 @JsonInclude(JsonInclude.Include.NON_EMPTY)
-public record PyrisLectureIngestionStatusUpdateDTO(String result, List<PyrisStageDTO> stages) {
+public record PyrisLectureIngestionStatusUpdateDTO(String result, List<PyrisStageDTO> stages, long jobId) {
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureUnitWebhookDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureUnitWebhookDTO.java
index 1bef48d26c2e..b2f2cde1019d 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureUnitWebhookDTO.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisLectureUnitWebhookDTO.java
@@ -8,6 +8,6 @@
  * providing necessary details such as lecture and course identifiers, names, and descriptions.
  */
 @JsonInclude(JsonInclude.Include.NON_EMPTY)
-public record PyrisLectureUnitWebhookDTO(Boolean toUpdate, String artemisBaseUrl, String pdfFile, Long lectureUnitId, String lectureUnitName, Long lectureId, String lectureName,
-        Long courseId, String courseName, String courseDescription) {
+public record PyrisLectureUnitWebhookDTO(String pdfFile, long lectureUnitId, String lectureUnitName, long lectureId, String lectureName, long courseId, String courseName,
+        String courseDescription) {
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureDeletionExecutionDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureDeletionExecutionDTO.java
new file mode 100644
index 000000000000..45f3bb809f01
--- /dev/null
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureDeletionExecutionDTO.java
@@ -0,0 +1,13 @@
+package de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook;
+
+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 PyrisWebhookLectureDeletionExecutionDTO(List<PyrisLectureUnitWebhookDTO> pyrisLectureUnits, PyrisPipelineExecutionSettingsDTO settings,
+        List<PyrisStageDTO> initialStages) {
+}
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureIngestionExecutionDTO.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureIngestionExecutionDTO.java
index 4ef052e91de3..d1eb256e27b0 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureIngestionExecutionDTO.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/dto/lectureingestionwebhook/PyrisWebhookLectureIngestionExecutionDTO.java
@@ -8,6 +8,5 @@
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
 
 @JsonInclude(JsonInclude.Include.NON_EMPTY)
-public record PyrisWebhookLectureIngestionExecutionDTO(List<PyrisLectureUnitWebhookDTO> pyrisLectureUnitWebhookDTOS, PyrisPipelineExecutionSettingsDTO settings,
-        List<PyrisStageDTO> initialStages) {
+public record PyrisWebhookLectureIngestionExecutionDTO(PyrisLectureUnitWebhookDTO pyrisLectureUnit, PyrisPipelineExecutionSettingsDTO settings, List<PyrisStageDTO> initialStages) {
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/IngestionWebhookJob.java b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/IngestionWebhookJob.java
index e29bb966520f..5dbfe0955520 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/IngestionWebhookJob.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/service/pyris/job/IngestionWebhookJob.java
@@ -7,7 +7,7 @@
  * An implementation of a PyrisJob for Lecture Ingestion in Pyris.
  * This job is used to reference the details of then Ingestion when Pyris sends a status update.
  */
-public record IngestionWebhookJob(String jobId) implements PyrisJob {
+public record IngestionWebhookJob(String jobId, long courseId, long lectureId, long lectureUnitId) implements PyrisJob {
 
     @Override
     public boolean canAccess(Course course) {
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/web/IrisResource.java b/src/main/java/de/tum/cit/aet/artemis/iris/web/IrisResource.java
index 58f40981a861..37e2983e39e0 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/web/IrisResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/web/IrisResource.java
@@ -2,34 +2,60 @@
 
 import static de.tum.cit.aet.artemis.core.config.Constants.PROFILE_IRIS;
 
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.boot.actuate.health.Status;
 import org.springframework.context.annotation.Profile;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
+import de.tum.cit.aet.artemis.core.domain.Course;
+import de.tum.cit.aet.artemis.core.repository.CourseRepository;
 import de.tum.cit.aet.artemis.core.repository.UserRepository;
+import de.tum.cit.aet.artemis.core.security.Role;
 import de.tum.cit.aet.artemis.core.security.annotations.EnforceAtLeastStudent;
+import de.tum.cit.aet.artemis.core.security.annotations.enforceRoleInCourse.EnforceAtLeastInstructorInCourse;
+import de.tum.cit.aet.artemis.core.service.AuthorizationCheckService;
+import de.tum.cit.aet.artemis.iris.dto.IngestionState;
 import de.tum.cit.aet.artemis.iris.dto.IrisStatusDTO;
 import de.tum.cit.aet.artemis.iris.service.IrisRateLimitService;
+import de.tum.cit.aet.artemis.iris.service.pyris.PyrisConnectorException;
 import de.tum.cit.aet.artemis.iris.service.pyris.PyrisHealthIndicator;
+import de.tum.cit.aet.artemis.iris.service.pyris.PyrisWebhookService;
 
 @Profile(PROFILE_IRIS)
 @RestController
 @RequestMapping("api/iris/")
 public class IrisResource {
 
+    private static final Logger log = LoggerFactory.getLogger(IrisResource.class);
+
     protected final UserRepository userRepository;
 
     protected final IrisRateLimitService irisRateLimitService;
 
     protected final PyrisHealthIndicator pyrisHealthIndicator;
 
-    public IrisResource(UserRepository userRepository, PyrisHealthIndicator pyrisHealthIndicator, IrisRateLimitService irisRateLimitService) {
+    private final AuthorizationCheckService authorizationCheckService;
+
+    private final CourseRepository courseRepository;
+
+    private final PyrisWebhookService pyrisWebhookService;
+
+    public IrisResource(UserRepository userRepository, PyrisHealthIndicator pyrisHealthIndicator, IrisRateLimitService irisRateLimitService,
+            AuthorizationCheckService authorizationCheckService, CourseRepository courseRepository, PyrisWebhookService pyrisWebhookService) {
         this.userRepository = userRepository;
         this.pyrisHealthIndicator = pyrisHealthIndicator;
         this.irisRateLimitService = irisRateLimitService;
+        this.authorizationCheckService = authorizationCheckService;
+        this.courseRepository = courseRepository;
+        this.pyrisWebhookService = pyrisWebhookService;
     }
 
     /**
@@ -47,4 +73,58 @@ public ResponseEntity<IrisStatusDTO> getStatus() {
         return ResponseEntity.ok(new IrisStatusDTO(health.getStatus() == Status.UP, rateLimitInfo));
     }
 
+    /**
+     * Retrieves the overall ingestion state of a lecture by communicating with Pyris.
+     *
+     * <p>
+     * This method sends a GET request to the external Pyris service to fetch the current ingestion
+     * state of all lectures in a course, identified by its `lectureId`. The ingestion state can be aggregated from
+     * multiple lecture units or can reflect the overall status of the lecture ingestion process.
+     * </p>
+     *
+     * @param courseId the ID of the lecture for which the ingestion state is being requested
+     * @return a {@link ResponseEntity} containing the {@link IngestionState} of the lecture,
+     */
+    @GetMapping("courses/{courseId}/lectures/ingestion-state")
+    @EnforceAtLeastInstructorInCourse
+    public ResponseEntity<Map<Long, IngestionState>> getStatusOfLectureIngestion(@PathVariable long courseId) {
+        try {
+            Course course = courseRepository.findByIdElseThrow(courseId);
+            authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, course, null);
+            return ResponseEntity.ok(pyrisWebhookService.getLecturesIngestionState(courseId));
+        }
+        catch (PyrisConnectorException e) {
+            log.error("Error fetching ingestion state for course {}", courseId, e);
+            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).build();
+        }
+    }
+
+    /**
+     * Retrieves the ingestion state of all lecture unit in a lecture by communicating with Pyris.
+     *
+     * <p>
+     * This method sends a GET request to the external Pyris service to fetch the current ingestion
+     * state of a lecture unit, identified by its ID. It constructs a request using the provided
+     * `lectureId` and `lectureUnitId` and returns the state of the ingestion process (e.g., NOT_STARTED,
+     * IN_PROGRESS, DONE, ERROR).
+     * </p>
+     *
+     * @param courseId  the ID of the lecture the unit belongs to
+     * @param lectureId the ID of the lecture the unit belongs to
+     * @return a {@link ResponseEntity} containing the {@link IngestionState} of the lecture unit,
+     */
+    @GetMapping("courses/{courseId}/lectures/{lectureId}/lecture-units/ingestion-state")
+    @EnforceAtLeastInstructorInCourse
+    public ResponseEntity<Map<Long, IngestionState>> getStatusOfLectureUnitsIngestion(@PathVariable long courseId, @PathVariable long lectureId) {
+        try {
+            Course course = courseRepository.findByIdElseThrow(courseId);
+            authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, course, null);
+            return ResponseEntity.ok(pyrisWebhookService.getLectureUnitsIngestionState(courseId, lectureId));
+        }
+        catch (PyrisConnectorException e) {
+            log.error("Error fetching ingestion state for lecture {}", lectureId, e);
+            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).build();
+        }
+    }
+
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java b/src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java
index 025a6ce4e897..73e4520c32a6 100644
--- a/src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/iris/web/open/PublicPyrisStatusUpdateResource.java
@@ -171,7 +171,6 @@ public ResponseEntity<Void> setStatusOfIngestionJob(@PathVariable String runId,
         }
 
         pyrisStatusUpdateService.handleStatusUpdate(ingestionWebhookJob, statusUpdateDTO);
-
         return ResponseEntity.ok().build();
     }
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java b/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java
index d0fd1afbf8a6..33ce07e7b6fb 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureRepository.java
@@ -28,6 +28,13 @@
 @Repository
 public interface LectureRepository extends ArtemisJpaRepository<Lecture, Long> {
 
+    @Query("""
+            SELECT lecture
+            FROM Lecture lecture
+            WHERE lecture.course.id = :courseId
+            """)
+    Set<Lecture> findAllByCourseId(@Param("courseId") Long courseId);
+
     @Query("""
             SELECT lecture
             FROM Lecture lecture
@@ -85,6 +92,14 @@ public interface LectureRepository extends ArtemisJpaRepository<Lecture, Long> {
             """)
     Optional<Lecture> findByIdWithLectureUnitsAndCompetencies(@Param("lectureId") Long lectureId);
 
+    @Query("""
+            SELECT lecture
+            FROM Lecture lecture
+                LEFT JOIN FETCH lecture.lectureUnits
+            WHERE lecture.id = :lectureId
+            """)
+    Optional<Lecture> findByIdWithLectureUnits(@Param("lectureId") Long lectureId);
+
     @Query("""
             SELECT lecture
             FROM Lecture lecture
@@ -165,6 +180,11 @@ Page<Lecture> findByTitleInLectureOrCourseAndUserHasAccessToCourse(@Param("parti
     @Cacheable(cacheNames = "lectureTitle", key = "#lectureId", unless = "#result == null")
     String getLectureTitle(@Param("lectureId") Long lectureId);
 
+    @NotNull
+    default Lecture findByIdWithLectureUnitsElseThrow(Long lectureId) {
+        return getValueElseThrow(findByIdWithLectureUnits(lectureId), lectureId);
+    }
+
     @NotNull
     default Lecture findByIdWithLectureUnitsAndCompetenciesElseThrow(Long lectureId) {
         return getValueElseThrow(findByIdWithLectureUnitsAndCompetencies(lectureId), lectureId);
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitRepository.java b/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitRepository.java
index 031fdc300e9d..42807551d308 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitRepository.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/repository/LectureUnitRepository.java
@@ -21,6 +21,13 @@
 @Repository
 public interface LectureUnitRepository extends ArtemisJpaRepository<LectureUnit, Long> {
 
+    @Query("""
+            SELECT lu
+            FROM LectureUnit lu
+            WHERE lu.id = :lectureUnitId
+            """)
+    Optional<LectureUnit> findById(@Param("lectureUnitId") long lectureUnitId);
+
     @Query("""
             SELECT lu
             FROM LectureUnit lu
@@ -104,4 +111,7 @@ default LectureUnit findByIdWithCompetenciesAndSlidesElseThrow(long lectureUnitI
         return getValueElseThrow(findWithCompetenciesAndSlidesById(lectureUnitId), lectureUnitId);
     }
 
+    default LectureUnit findByIdElseThrow(long lectureUnitId) {
+        return getValueElseThrow(findById(lectureUnitId), lectureUnitId);
+    }
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureService.java b/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureService.java
index 3095605139a1..7654884f753d 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureService.java
@@ -177,16 +177,14 @@ public void delete(Lecture lecture, boolean updateCompetencyProgress) {
      * Ingest the lectures when triggered by the ingest lectures button
      *
      * @param lectures set of lectures to be ingested
-     * @return returns the job token if the operation is successful else it returns null
      */
-    public boolean ingestLecturesInPyris(Set<Lecture> lectures) {
+    public void ingestLecturesInPyris(Set<Lecture> lectures) {
         if (pyrisWebhookService.isPresent()) {
             List<AttachmentUnit> attachmentUnitList = lectures.stream().flatMap(lec -> lec.getLectureUnits().stream()).filter(unit -> unit instanceof AttachmentUnit)
                     .map(unit -> (AttachmentUnit) unit).toList();
-            if (!attachmentUnitList.isEmpty()) {
-                return pyrisWebhookService.get().addLectureUnitsToPyrisDB(attachmentUnitList) != null;
+            for (AttachmentUnit attachmentUnit : attachmentUnitList) {
+                pyrisWebhookService.get().addLectureUnitToPyrisDB(attachmentUnit);
             }
         }
-        return false;
     }
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureUnitService.java b/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureUnitService.java
index bda282499738..74ec8a5fa90c 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureUnitService.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/service/LectureUnitService.java
@@ -19,8 +19,12 @@
 import jakarta.ws.rs.BadRequestException;
 
 import org.hibernate.Hibernate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.context.annotation.Profile;
 import org.springframework.dao.DataIntegrityViolationException;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Service;
 
 import de.tum.cit.aet.artemis.atlas.domain.competency.CompetencyLectureUnitLink;
@@ -47,6 +51,8 @@
 @Service
 public class LectureUnitService {
 
+    private static final Logger log = LoggerFactory.getLogger(LectureUnitService.class);
+
     private final LectureUnitRepository lectureUnitRepository;
 
     private final LectureRepository lectureRepository;
@@ -220,6 +226,30 @@ public URL validateUrlStringAndReturnUrl(String urlString) {
         }
     }
 
+    /**
+     * This method is responsible for ingesting a specific `LectureUnit` into Pyris, but only if it is an instance of
+     * `AttachmentUnit`. If the Pyris webhook service is available, it attempts to add the `LectureUnit` to the Pyris
+     * database.
+     * The method responds with different HTTP status codes based on the result:
+     * Returns {OK} if the ingestion is successful.
+     * Returns {SERVICE_UNAVAILABLE} if the Pyris webhook service is unavailable or if the ingestion fails.
+     * Returns {400 BAD_REQUEST} if the provided lecture unit is not of type {AttachmentUnit}.
+     *
+     * @param lectureUnit the lecture unit to be ingested, which must be an instance of AttachmentUnit.
+     * @return ResponseEntity<Void> representing the outcome of the operation with the appropriate HTTP status.
+     */
+    public ResponseEntity<Void> ingestLectureUnitInPyris(LectureUnit lectureUnit) {
+        if (!(lectureUnit instanceof AttachmentUnit)) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        }
+        if (pyrisWebhookService.isEmpty()) {
+            log.error("Could not send Lecture Unit to Pyris: Pyris webhook service is not available, check if IRIS is enabled.");
+            return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).build();
+        }
+        boolean isIngested = pyrisWebhookService.get().addLectureUnitToPyrisDB((AttachmentUnit) lectureUnit) != null;
+        return ResponseEntity.status(isIngested ? HttpStatus.OK : HttpStatus.BAD_REQUEST).build();
+    }
+
     /**
      * Disconnects the competency exercise links from the exercise before the cycle is broken by the deserialization.
      *
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java b/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java
index baecd6cd7c57..6d0a6f0f33e9 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureResource.java
@@ -276,21 +276,21 @@ public ResponseEntity<Lecture> importLecture(@PathVariable long sourceLectureId,
     @Profile(PROFILE_IRIS)
     @PostMapping("courses/{courseId}/ingest")
     @EnforceAtLeastInstructorInCourse
-    public ResponseEntity<Boolean> ingestLectures(@PathVariable Long courseId, @RequestParam(required = false) Optional<Long> lectureId) {
-        log.debug("REST request to ingest lectures of course : {}", courseId);
+    public ResponseEntity<Void> ingestLectures(@PathVariable Long courseId, @RequestParam(required = false) Optional<Long> lectureId) {
         Course course = courseRepository.findByIdWithLecturesAndLectureUnitsElseThrow(courseId);
+        authCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.INSTRUCTOR, course, null);
         if (lectureId.isPresent()) {
             Optional<Lecture> lectureToIngest = course.getLectures().stream().filter(lecture -> lecture.getId().equals(lectureId.get())).findFirst();
             if (lectureToIngest.isPresent()) {
                 Set<Lecture> lecturesToIngest = new HashSet<>();
                 lecturesToIngest.add(lectureToIngest.get());
-                return ResponseEntity.ok().body(lectureService.ingestLecturesInPyris(lecturesToIngest));
+                lectureService.ingestLecturesInPyris(lecturesToIngest);
+                return ResponseEntity.ok().build();
             }
-            return ResponseEntity.badRequest()
-                    .headers(HeaderUtil.createAlert(applicationName, "Could not send lecture to Iris, no lecture found with the provided id.", "idExists")).body(null);
-
+            return ResponseEntity.badRequest().headers(HeaderUtil.createAlert(applicationName, "artemisApp.iris.ingestionAlert.allLecturesError", "idExists")).body(null);
         }
-        return ResponseEntity.ok().body(lectureService.ingestLecturesInPyris(course.getLectures()));
+        lectureService.ingestLecturesInPyris(course.getLectures());
+        return ResponseEntity.ok().build();
     }
 
     /**
diff --git a/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java b/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java
index b14667346674..78bb7d708f86 100644
--- a/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java
+++ b/src/main/java/de/tum/cit/aet/artemis/lecture/web/LectureUnitResource.java
@@ -4,6 +4,7 @@
 
 import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
 
 import jakarta.validation.Valid;
 
@@ -11,6 +12,7 @@
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Value;
 import org.springframework.context.annotation.Profile;
+import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.DeleteMapping;
 import org.springframework.web.bind.annotation.GetMapping;
@@ -156,7 +158,7 @@ public ResponseEntity<Void> completeLectureUnit(@PathVariable Long lectureUnitId
      */
     @DeleteMapping("lectures/{lectureId}/lecture-units/{lectureUnitId}")
     @EnforceAtLeastInstructor
-    public ResponseEntity<Void> deleteLectureUnit(@PathVariable Long lectureUnitId, @PathVariable Long lectureId) {
+    public ResponseEntity<Void> deleteLectureUnit(@PathVariable long lectureUnitId, @PathVariable Long lectureId) {
         log.info("REST request to delete lecture unit: {}", lectureUnitId);
         LectureUnit lectureUnit = lectureUnitRepository.findByIdWithCompetenciesBidirectionalElseThrow(lectureUnitId);
         if (lectureUnit.getLecture() == null || lectureUnit.getLecture().getCourse() == null) {
@@ -200,11 +202,35 @@ public ResponseEntity<LectureUnitForLearningPathNodeDetailsDTO> getLectureUnitFo
      */
     @GetMapping("lecture-units/{lectureUnitId}")
     @EnforceAtLeastStudent
-    public ResponseEntity<LectureUnit> getLectureUnitById(@PathVariable @Valid Long lectureUnitId) {
+    public ResponseEntity<LectureUnit> getLectureUnitById(@PathVariable @Valid long lectureUnitId) {
         log.debug("REST request to get lecture unit with id: {}", lectureUnitId);
         var lectureUnit = lectureUnitRepository.findByIdWithCompletedUsersElseThrow(lectureUnitId);
         authorizationCheckService.checkHasAtLeastRoleInCourseElseThrow(Role.STUDENT, lectureUnit.getLecture().getCourse(), null);
         lectureUnit.setCompleted(lectureUnit.isCompletedFor(userRepository.getUser()));
         return ResponseEntity.ok(lectureUnit);
     }
+
+    /**
+     * This endpoint triggers the ingestion process for a specified lecture unit into Pyris.
+     *
+     * @param lectureId     the ID of the lecture to which the lecture unit belongs
+     * @param lectureUnitId the ID of the lecture unit to be ingested
+     * @return ResponseEntity<Void> with the status of the ingestion operation.
+     *         Returns 200 OK if the ingestion is successfully started.
+     *         Returns 400 BAD_REQUEST if the lecture unit cannot be ingested.
+     *         Returns SERVICE_UNAVAILABLE if the Pyris service is unavailable or
+     *         ingestion fails for another reason.
+     */
+    @PostMapping("lectures/{lectureId}/lecture-units/{lectureUnitId}/ingest")
+    @EnforceAtLeastInstructor
+    public ResponseEntity<Void> ingestLectureUnit(@PathVariable long lectureId, @PathVariable long lectureUnitId) {
+        Lecture lecture = this.lectureRepository.findByIdWithLectureUnitsElseThrow(lectureId);
+        Optional<LectureUnit> lectureUnitOptional = lecture.getLectureUnits().stream().filter(lu -> lu.getId() == lectureUnitId).findFirst();
+        if (lectureUnitOptional.isEmpty()) {
+            return ResponseEntity.status(HttpStatus.BAD_REQUEST).build();
+        }
+        LectureUnit lectureUnit = lectureUnitOptional.get();
+        authorizationCheckService.checkHasAtLeastRoleForLectureElseThrow(Role.INSTRUCTOR, lectureUnit.getLecture(), null);
+        return lectureUnitService.ingestLectureUnitInPyris(lectureUnit);
+    }
 }
diff --git a/src/main/java/de/tum/cit/aet/artemis/programming/service/localci/scaparser/format/sarif/Result.java b/src/main/java/de/tum/cit/aet/artemis/programming/service/localci/scaparser/format/sarif/Result.java
index 4230d64dcd9c..5b280e65e9c0 100644
--- a/src/main/java/de/tum/cit/aet/artemis/programming/service/localci/scaparser/format/sarif/Result.java
+++ b/src/main/java/de/tum/cit/aet/artemis/programming/service/localci/scaparser/format/sarif/Result.java
@@ -89,7 +89,7 @@ public enum Kind {
 
         private final String value;
 
-        private final static Map<String, Kind> CONSTANTS = new HashMap<>();
+        private static final Map<String, Kind> CONSTANTS = new HashMap<>();
 
         static {
             for (Kind c : values()) {
@@ -140,7 +140,7 @@ public enum Level {
 
         private final String value;
 
-        private final static Map<String, Level> CONSTANTS = new HashMap<>();
+        private static final Map<String, Level> CONSTANTS = new HashMap<>();
 
         static {
             for (Level c : values()) {
diff --git a/src/main/webapp/app/entities/lecture-unit/attachmentUnit.model.ts b/src/main/webapp/app/entities/lecture-unit/attachmentUnit.model.ts
index 9d1e9986329e..d83c834fe83a 100644
--- a/src/main/webapp/app/entities/lecture-unit/attachmentUnit.model.ts
+++ b/src/main/webapp/app/entities/lecture-unit/attachmentUnit.model.ts
@@ -6,8 +6,17 @@ export class AttachmentUnit extends LectureUnit {
     public description?: string;
     public attachment?: Attachment;
     public slides?: Slide[];
+    public pyrisIngestionState?: IngestionState;
 
     constructor() {
         super(LectureUnitType.ATTACHMENT);
     }
 }
+
+export enum IngestionState {
+    NOT_STARTED = 'NOT_STARTED',
+    IN_PROGRESS = 'IN_PROGRESS',
+    DONE = 'DONE',
+    ERROR = 'ERROR',
+    PARTIALLY_INGESTED = 'PARTIALLY_INGESTED',
+}
diff --git a/src/main/webapp/app/entities/lecture.model.ts b/src/main/webapp/app/entities/lecture.model.ts
index 3f039edafe40..d213ed53de1d 100644
--- a/src/main/webapp/app/entities/lecture.model.ts
+++ b/src/main/webapp/app/entities/lecture.model.ts
@@ -4,6 +4,7 @@ import { Attachment } from 'app/entities/attachment.model';
 import { Post } from 'app/entities/metis/post.model';
 import { Course } from 'app/entities/course.model';
 import { LectureUnit } from 'app/entities/lecture-unit/lectureUnit.model';
+import { IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 
 export class Lecture implements BaseEntity {
     id?: number;
@@ -21,6 +22,7 @@ export class Lecture implements BaseEntity {
     channelName?: string;
     isAtLeastEditor?: boolean;
     isAtLeastInstructor?: boolean;
+    ingested?: IngestionState;
 
     constructor() {}
 }
diff --git a/src/main/webapp/app/lecture/lecture-detail.component.ts b/src/main/webapp/app/lecture/lecture-detail.component.ts
index ef9e7344b4eb..59692860562f 100644
--- a/src/main/webapp/app/lecture/lecture-detail.component.ts
+++ b/src/main/webapp/app/lecture/lecture-detail.component.ts
@@ -9,6 +9,7 @@ import { ArtemisMarkdownService } from 'app/shared/markdown.service';
 import { LectureService } from 'app/lecture/lecture.service';
 import { IrisSettingsService } from 'app/iris/settings/shared/iris-settings.service';
 import { Subscription } from 'rxjs';
+import { AlertService } from 'app/core/util/alert.service';
 @Component({
     selector: 'jhi-lecture-detail',
     templateUrl: './lecture-detail.component.html',
@@ -30,6 +31,7 @@ export class LectureDetailComponent implements OnInit, OnDestroy {
     constructor(
         private activatedRoute: ActivatedRoute,
         private artemisMarkdown: ArtemisMarkdownService,
+        private alertService: AlertService,
         protected lectureService: LectureService,
         private profileService: ProfileService,
         private irisSettingsService: IrisSettingsService,
@@ -93,7 +95,11 @@ export class LectureDetailComponent implements OnInit, OnDestroy {
      */
     ingestLectureInPyris() {
         this.lectureService.ingestLecturesInPyris(this.lecture.course!.id!, this.lecture.id).subscribe({
-            error: (error) => console.error(`Failed to send Ingestion request`, error),
+            next: () => this.alertService.success('artemisApp.iris.ingestionAlert.lectureSuccess'),
+            error: (error) => {
+                this.alertService.error('artemisApp.iris.ingestionAlert.lectureError');
+                console.error('Failed to send Ingestion request', error);
+            },
         });
     }
 }
diff --git a/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component.html b/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component.html
index 677b82c94a9b..d13e7e6ba09d 100644
--- a/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component.html
+++ b/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component.html
@@ -68,27 +68,51 @@
                         </div>
                     </div>
                     <div class="d-flex gap-1 flex-column justify-content-center col-3 col-sm-2 col-lg-1" role="group">
-                        <div class="d-flex gap-1 w-100">
-                            @if (lecture.course?.id && showCompetencies) {
-                                <jhi-competencies-popover
-                                    class="flex-grow-1"
-                                    [courseId]="lecture.course!.id!"
-                                    [competencyLinks]="lectureUnit.competencyLinks || []"
-                                    [navigateTo]="'competencyManagement'"
-                                />
-                            }
-                            @if (viewButtonAvailable[lectureUnit.id!]) {
-                                <a
+                        @if (this.lectureIngestionEnabled && this.lectureUnit.type == LectureUnitType.ATTACHMENT) {
+                            <div class="d-flex gap-1 w-100">
+                                @if (lecture.course?.id && showCompetencies) {
+                                    <jhi-competencies-popover
+                                        class="flex-grow-1"
+                                        [courseId]="lecture.course!.id!"
+                                        [competencyLinks]="lectureUnit.competencyLinks || []"
+                                        [navigateTo]="'competencyManagement'"
+                                    />
+                                }
+                                <button
                                     type="button"
                                     class="btn btn-primary btn-sm flex-grow-1"
-                                    [routerLink]="['/course-management', lecture.course?.id, 'lectures', lecture.id, 'unit-management', 'attachment-units', lectureUnit.id, 'view']"
-                                    [ngbTooltip]="'entity.action.view' | artemisTranslate"
+                                    [ngClass]="{
+                                        error: getIcon(lectureUnit) === faRepeat,
+                                        'btn-success': getIcon(lectureUnit) === faCheckCircle,
+                                    }"
+                                    (click)="onIngestButtonClicked(lectureUnit.id!)"
+                                    [ngbTooltip]="'entity.action.sendToIris' | artemisTranslate"
                                 >
-                                    <fa-icon [icon]="faEye" />
-                                </a>
-                            }
-                        </div>
-
+                                    <fa-icon [icon]="getIcon(lectureUnit)" />
+                                </button>
+                            </div>
+                        } @else {
+                            <div class="d-flex gap-1 w-100">
+                                @if (lecture.course?.id && showCompetencies) {
+                                    <jhi-competencies-popover
+                                        class="flex-grow-1"
+                                        [courseId]="lecture.course!.id!"
+                                        [competencyLinks]="lectureUnit.competencyLinks || []"
+                                        [navigateTo]="'competencyManagement'"
+                                    />
+                                }
+                            </div>
+                        }
+                        @if (viewButtonAvailable[lectureUnit.id!]) {
+                            <a
+                                type="button"
+                                class="btn btn-primary btn-sm flex-grow-1"
+                                [routerLink]="['/course-management', lecture.course?.id, 'lectures', lecture.id, 'unit-management', 'attachment-units', lectureUnit.id, 'view']"
+                                [ngbTooltip]="'entity.action.view' | artemisTranslate"
+                            >
+                                <fa-icon [icon]="faEye" />
+                            </a>
+                        }
                         <div class="d-flex gap-1 w-100">
                             @if (this.emitEditEvents) {
                                 @if (editButtonAvailable(lectureUnit)) {
diff --git a/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component.ts b/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component.ts
index dd3897bf0318..6ca545a7881c 100644
--- a/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component.ts
+++ b/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component.ts
@@ -10,10 +10,13 @@ import { onError } from 'app/shared/util/global.utils';
 import { Subject, Subscription } from 'rxjs';
 import { LectureUnitService } from 'app/lecture/lecture-unit/lecture-unit-management/lectureUnit.service';
 import { ActionType } from 'app/shared/delete-dialog/delete-dialog.model';
-import { AttachmentUnit } from 'app/entities/lecture-unit/attachmentUnit.model';
+import { AttachmentUnit, IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 import { ExerciseUnit } from 'app/entities/lecture-unit/exerciseUnit.model';
-import { faEye, faPencilAlt, faTrash } from '@fortawesome/free-solid-svg-icons';
+import { IconDefinition, faCheckCircle, faEye, faFileExport, faPencilAlt, faRepeat, faSpinner, faTrash } from '@fortawesome/free-solid-svg-icons';
 import { CdkDragDrop, moveItemInArray } from '@angular/cdk/drag-drop';
+import { PROFILE_IRIS } from 'app/app.constants';
+import { ProfileService } from 'app/shared/layouts/profiles/profile.service';
+import { IrisSettingsService } from 'app/iris/settings/shared/iris-settings.service';
 
 @Component({
     selector: 'jhi-lecture-unit-management',
@@ -43,7 +46,9 @@ export class LectureUnitManagementComponent implements OnInit, OnDestroy {
     readonly ActionType = ActionType;
     private dialogErrorSource = new Subject<string>();
     dialogError$ = this.dialogErrorSource.asObservable();
-
+    private profileInfoSubscription: Subscription;
+    irisEnabled = false;
+    lectureIngestionEnabled = false;
     routerEditLinksBase: { [key: string]: string } = {
         [LectureUnitType.ATTACHMENT]: 'attachment-units',
         [LectureUnitType.VIDEO]: 'video-units',
@@ -52,9 +57,13 @@ export class LectureUnitManagementComponent implements OnInit, OnDestroy {
     };
 
     // Icons
-    faTrash = faTrash;
-    faPencilAlt = faPencilAlt;
-    faEye = faEye;
+    readonly faTrash = faTrash;
+    readonly faPencilAlt = faPencilAlt;
+    readonly faEye = faEye;
+    readonly faFileExport = faFileExport;
+    readonly faRepeat = faRepeat;
+    readonly faCheckCircle = faCheckCircle;
+    readonly faSpinner = faSpinner;
 
     constructor(
         private activatedRoute: ActivatedRoute,
@@ -62,6 +71,8 @@ export class LectureUnitManagementComponent implements OnInit, OnDestroy {
         private lectureService: LectureService,
         private alertService: AlertService,
         public lectureUnitService: LectureUnitService,
+        private profileService: ProfileService,
+        private irisSettingsService: IrisSettingsService,
     ) {}
 
     ngOnDestroy(): void {
@@ -69,6 +80,7 @@ export class LectureUnitManagementComponent implements OnInit, OnDestroy {
         this.updateOrderSubjectSubscription.unsubscribe();
         this.dialogErrorSource.unsubscribe();
         this.navigationEndSubscription.unsubscribe();
+        this.profileInfoSubscription?.unsubscribe();
     }
 
     ngOnInit(): void {
@@ -111,6 +123,10 @@ export class LectureUnitManagementComponent implements OnInit, OnDestroy {
                         this.lectureUnits.forEach((lectureUnit) => {
                             this.viewButtonAvailable[lectureUnit.id!] = this.isViewButtonAvailable(lectureUnit);
                         });
+                        this.initializeProfileInfo();
+                        if (this.lectureIngestionEnabled) {
+                            this.updateIngestionStates();
+                        }
                     } else {
                         this.lectureUnits = [];
                     }
@@ -132,6 +148,17 @@ export class LectureUnitManagementComponent implements OnInit, OnDestroy {
             });
     }
 
+    initializeProfileInfo() {
+        this.profileInfoSubscription = this.profileService.getProfileInfo().subscribe(async (profileInfo) => {
+            this.irisEnabled = profileInfo.activeProfiles.includes(PROFILE_IRIS);
+            if (this.irisEnabled && this.lecture.course && this.lecture.course.id) {
+                this.irisSettingsService.getCombinedCourseSettings(this.lecture.course.id).subscribe((settings) => {
+                    this.lectureIngestionEnabled = settings?.irisLectureIngestionSettings?.enabled || false;
+                });
+            }
+        });
+    }
+
     drop(event: CdkDragDrop<LectureUnit[]>) {
         moveItemInArray(this.lectureUnits, event.previousIndex, event.currentIndex);
         this.updateOrderSubject.next('');
@@ -239,4 +266,66 @@ export class LectureUnitManagementComponent implements OnInit, OnDestroy {
                 return undefined;
         }
     }
+
+    /**
+     * Fetches the ingestion state for each lecture unit asynchronously and updates the lecture unit object.
+     */
+    updateIngestionStates() {
+        this.lectureUnitService.getIngestionState(this.lecture.course!.id!, this.lecture.id!).subscribe({
+            next: (res: HttpResponse<Record<number, IngestionState>>) => {
+                if (res.body) {
+                    const ingestionStatesMap = res.body;
+                    this.lectureUnits.forEach((lectureUnit) => {
+                        if (lectureUnit.id) {
+                            const ingestionState = ingestionStatesMap[lectureUnit.id];
+                            if (ingestionState !== undefined) {
+                                (<AttachmentUnit>lectureUnit).pyrisIngestionState = ingestionState;
+                            }
+                        }
+                    });
+                }
+            },
+            error: (err: HttpErrorResponse) => {
+                console.error(`Error fetching ingestion states for lecture ${this.lecture.id}`, err);
+                this.alertService.error('artemisApp.iris.ingestionAlert.pyrisError');
+            },
+        });
+    }
+
+    onIngestButtonClicked(lectureUnitId: number) {
+        const unitIndex: number = this.lectureUnits.findIndex((unit) => unit.id === lectureUnitId);
+        if (unitIndex > -1) {
+            const unit: AttachmentUnit = this.lectureUnits[unitIndex];
+            unit.pyrisIngestionState = IngestionState.IN_PROGRESS;
+            this.lectureUnits[unitIndex] = unit;
+        }
+        this.lectureUnitService.ingestLectureUnitInPyris(lectureUnitId, this.lecture.id!).subscribe({
+            next: () => this.alertService.success('artemisApp.iris.ingestionAlert.lectureUnitSuccess'),
+            error: (error) => {
+                if (error.status === 400) {
+                    this.alertService.error('artemisApp.iris.ingestionAlert.lectureUnitError');
+                } else if (error.status === 503) {
+                    this.alertService.error('artemisApp.iris.ingestionAlert.pyrisUnavailable');
+                } else {
+                    this.alertService.error('artemisApp.iris.ingestionAlert.pyrisError');
+                }
+                console.error('Failed to send lecture unit ingestion request', error);
+            },
+        });
+    }
+
+    getIcon(attachmentUnit: AttachmentUnit): IconDefinition {
+        switch (attachmentUnit.pyrisIngestionState) {
+            case IngestionState.NOT_STARTED:
+                return this.faFileExport;
+            case IngestionState.IN_PROGRESS:
+                return this.faSpinner;
+            case IngestionState.DONE:
+                return this.faCheckCircle;
+            case IngestionState.ERROR:
+                return this.faRepeat;
+            default:
+                return this.faFileExport;
+        }
+    }
 }
diff --git a/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lectureUnit.service.ts b/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lectureUnit.service.ts
index 2825fed950e2..053b29704369 100644
--- a/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lectureUnit.service.ts
+++ b/src/main/webapp/app/lecture/lecture-unit/lecture-unit-management/lectureUnit.service.ts
@@ -7,7 +7,7 @@ import { onError } from 'app/shared/util/global.utils';
 import { Observable } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { Injectable } from '@angular/core';
-import { AttachmentUnit } from 'app/entities/lecture-unit/attachmentUnit.model';
+import { AttachmentUnit, IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 import { AttachmentService } from 'app/lecture/attachment.service';
 import { ExerciseUnit } from 'app/entities/lecture-unit/exerciseUnit.model';
 import { ExerciseService } from 'app/exercises/shared/exercise/exercise.service';
@@ -167,4 +167,28 @@ export class LectureUnitService {
     getLectureUnitById(lectureUnitId: number): Observable<LectureUnit> {
         return this.httpClient.get<LectureUnit>(`${this.resourceURL}/lecture-units/${lectureUnitId}`);
     }
+    /**
+     * Fetch the actual ingestion state for all lecture units from an external service (e.g., Pyris).
+     * @param courseId
+     * @param lectureId ID of the lecture
+     * @returns Observable with the ingestion state
+     */
+    getIngestionState(courseId: number, lectureId: number): Observable<HttpResponse<Record<number, IngestionState>>> {
+        return this.httpClient.get<Record<number, IngestionState>>(`${this.resourceURL}/iris/courses/${courseId}/lectures/${lectureId}/lecture-units/ingestion-state`, {
+            observe: 'response',
+        });
+    }
+
+    /**
+     * Triggers the ingestion of one lecture unit.
+     *
+     * @param lectureUnitId - The ID of the lecture unit to be ingested.
+     * @param lectureId - The ID of the lecture to which the unit belongs.
+     * @returns An Observable with an HttpResponse 200 if the request was successful .
+     */
+    ingestLectureUnitInPyris(lectureUnitId: number, lectureId: number): Observable<HttpResponse<void>> {
+        return this.httpClient.post<void>(`${this.resourceURL}/lectures/${lectureId}/lecture-units/${lectureUnitId}/ingest`, null, {
+            observe: 'response',
+        });
+    }
 }
diff --git a/src/main/webapp/app/lecture/lecture.component.html b/src/main/webapp/app/lecture/lecture.component.html
index 68a82448b85e..51e581861e0f 100644
--- a/src/main/webapp/app/lecture/lecture.component.html
+++ b/src/main/webapp/app/lecture/lecture.component.html
@@ -118,6 +118,12 @@ <h2 id="page-heading">
                             <span jhiTranslate="artemisApp.lecture.endDate"></span>
                             <fa-icon [icon]="faSort" />
                         </th>
+                        @if (lectureIngestionEnabled) {
+                            <th jhiSortBy="ingested">
+                                <span jhiTranslate="artemisApp.lecture.ingestionState"></span>
+                                <fa-icon [icon]="faSort" />
+                            </th>
+                        }
                         <th></th>
                     </tr>
                 </thead>
@@ -134,6 +140,30 @@ <h2 id="page-heading">
                             <td>{{ lecture.visibleDate | artemisDate }}</td>
                             <td>{{ lecture.startDate | artemisDate }}</td>
                             <td>{{ lecture.endDate | artemisDate }}</td>
+                            @if (lectureIngestionEnabled) {
+                                <td>
+                                    @switch (lecture.ingested) {
+                                        @case (IngestionState.NOT_STARTED) {
+                                            <span jhiTranslate="artemisApp.iris.ingestionStates.notStarted"></span>
+                                        }
+                                        @case (IngestionState.IN_PROGRESS) {
+                                            <span jhiTranslate="artemisApp.iris.ingestionStates.inProgress"></span>
+                                        }
+                                        @case (IngestionState.PARTIALLY_INGESTED) {
+                                            <span jhiTranslate="artemisApp.iris.ingestionStates.partiallyIngested"></span>
+                                        }
+                                        @case (IngestionState.DONE) {
+                                            <span jhiTranslate="artemisApp.iris.ingestionStates.done"></span>
+                                        }
+                                        @case (IngestionState.ERROR) {
+                                            <span jhiTranslate="artemisApp.iris.ingestionStates.error"></span>
+                                        }
+                                        @default {
+                                            <span jhiTranslate="artemisApp.iris.ingestionStates.loading"></span>
+                                        }
+                                    }
+                                </td>
+                            }
                             <td class="text-end">
                                 <div class="btn-group flex-btn-group-container">
                                     <div class="btn-group-vertical me-1 mb-1">
diff --git a/src/main/webapp/app/lecture/lecture.component.ts b/src/main/webapp/app/lecture/lecture.component.ts
index 6f4d832c5167..19c4dc417eb1 100644
--- a/src/main/webapp/app/lecture/lecture.component.ts
+++ b/src/main/webapp/app/lecture/lecture.component.ts
@@ -16,6 +16,7 @@ import { Subject, Subscription } from 'rxjs';
 import { DocumentationType } from 'app/shared/components/documentation-button/documentation-button.component';
 import { SortService } from 'app/shared/service/sort.service';
 import { IrisSettingsService } from 'app/iris/settings/shared/iris-settings.service';
+import { IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 
 export enum LectureDateFilter {
     PAST = 'filterPast',
@@ -44,6 +45,7 @@ export class LectureComponent implements OnInit, OnDestroy {
 
     readonly filterType = LectureDateFilter;
     readonly documentationType: DocumentationType = 'Lecture';
+    readonly ingestionState: IngestionState;
 
     // Icons
     faPlus = faPlus;
@@ -57,6 +59,8 @@ export class LectureComponent implements OnInit, OnDestroy {
     faSort = faSort;
     lectureIngestionEnabled = false;
 
+    protected readonly IngestionState = IngestionState;
+
     private profileInfoSubscription: Subscription;
 
     constructor(
@@ -75,7 +79,6 @@ export class LectureComponent implements OnInit, OnDestroy {
 
     ngOnInit() {
         this.courseId = Number(this.route.snapshot.paramMap.get('courseId'));
-        this.loadAll();
         this.profileInfoSubscription = this.profileService.getProfileInfo().subscribe(async (profileInfo) => {
             this.irisEnabled = profileInfo.activeProfiles.includes(PROFILE_IRIS);
             if (this.irisEnabled) {
@@ -84,6 +87,7 @@ export class LectureComponent implements OnInit, OnDestroy {
                 });
             }
         });
+        this.loadAll();
     }
 
     ngOnDestroy(): void {
@@ -150,14 +154,21 @@ export class LectureComponent implements OnInit, OnDestroy {
 
     private loadAll() {
         this.lectureService
-            .findAllByCourseId(this.courseId)
+            .findAllByCourseIdWithSlides(this.courseId)
             .pipe(
                 filter((res: HttpResponse<Lecture[]>) => res.ok),
                 map((res: HttpResponse<Lecture[]>) => res.body),
             )
             .subscribe({
                 next: (res: Lecture[]) => {
-                    this.lectures = res;
+                    this.lectures = res.map((lectureData) => {
+                        const lecture = new Lecture();
+                        Object.assign(lecture, lectureData);
+                        return lecture;
+                    });
+                    if (this.lectureIngestionEnabled) {
+                        this.updateIngestionStates();
+                    }
                     this.applyFilters();
                 },
                 error: (res: HttpErrorResponse) => onError(this.alertService, res),
@@ -208,8 +219,37 @@ export class LectureComponent implements OnInit, OnDestroy {
     ingestLecturesInPyris() {
         if (this.lectures.first()) {
             this.lectureService.ingestLecturesInPyris(this.lectures.first()!.course!.id!).subscribe({
-                error: (error) => console.error('Failed to send Ingestion request', error),
+                next: () => this.alertService.success('artemisApp.iris.ingestionAlert.allLecturesSuccess'),
+                error: (error) => {
+                    this.alertService.error('artemisApp.iris.ingestionAlert.allLecturesError');
+                    console.error('Failed to send Lectures Ingestion request', error);
+                },
             });
         }
     }
+
+    /**
+     * Fetches the ingestion state for all lecture asynchronously and updates all the lectures ingestion state.
+     */
+    updateIngestionStates() {
+        this.lectureService.getIngestionState(this.courseId).subscribe({
+            next: (res: HttpResponse<Record<number, IngestionState>>) => {
+                if (res.body) {
+                    const ingestionStatesMap = res.body;
+                    this.lectures.forEach((lecture) => {
+                        if (lecture.id) {
+                            const ingestionState = ingestionStatesMap[lecture.id];
+                            if (ingestionState !== undefined) {
+                                lecture.ingested = ingestionState;
+                            }
+                        }
+                    });
+                }
+            },
+            error: (err: HttpErrorResponse) => {
+                console.error(`Error fetching ingestion state for lecture in course ${this.courseId}`, err);
+                this.alertService.error('artemisApp.iris.ingestionAlert.pyrisError');
+            },
+        });
+    }
 }
diff --git a/src/main/webapp/app/lecture/lecture.service.ts b/src/main/webapp/app/lecture/lecture.service.ts
index 7e1259860fa3..e6b508e6695a 100644
--- a/src/main/webapp/app/lecture/lecture.service.ts
+++ b/src/main/webapp/app/lecture/lecture.service.ts
@@ -8,6 +8,7 @@ import { AccountService } from 'app/core/auth/account.service';
 import { LectureUnitService } from 'app/lecture/lecture-unit/lecture-unit-management/lectureUnit.service';
 import { convertDateFromClient, convertDateFromServer } from 'app/utils/date.utils';
 import { EntityTitleService, EntityType } from 'app/shared/layouts/navbar/entity-title.service';
+import { IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 
 type EntityResponseType = HttpResponse<Lecture>;
 type EntityArrayResponseType = HttpResponse<Lecture[]>;
@@ -117,17 +118,23 @@ export class LectureService {
      * @param courseId Course containing the lecture(s)
      * @param lectureId The lecture to be ingested in pyris
      */
-    ingestLecturesInPyris(courseId: number, lectureId?: number): Observable<HttpResponse<boolean>> {
+    ingestLecturesInPyris(courseId: number, lectureId?: number): Observable<HttpResponse<void>> {
         let params = new HttpParams();
         if (lectureId !== undefined) {
             params = params.set('lectureId', lectureId.toString());
         }
-
-        return this.http.post<boolean>(`api/courses/${courseId}/ingest`, null, {
+        return this.http.post<void>(`api/courses/${courseId}/ingest`, null, {
             params: params,
             observe: 'response',
         });
     }
+    /**
+     * Fetch the ingestion state of all the lectures inside the course specified
+     * @param courseId
+     */
+    getIngestionState(courseId: number): Observable<HttpResponse<Record<number, IngestionState>>> {
+        return this.http.get<Record<number, IngestionState>>(`api/iris/courses/${courseId}/lectures/ingestion-state`, { observe: 'response' });
+    }
     /**
      * Clones and imports the lecture to the course
      *
diff --git a/src/main/webapp/app/overview/course-overview.service.ts b/src/main/webapp/app/overview/course-overview.service.ts
index 1aeb84cf5045..97b42ff6dc3f 100644
--- a/src/main/webapp/app/overview/course-overview.service.ts
+++ b/src/main/webapp/app/overview/course-overview.service.ts
@@ -262,7 +262,7 @@ export class CourseOverviewService {
     mapLecturesToSidebarCardElements(lectures: Lecture[]) {
         return lectures.map((lecture) => this.mapLectureToSidebarCardElement(lecture));
     }
-    mapTutorialGroupsToSidebarCardElements(tutorialGroups: Lecture[]) {
+    mapTutorialGroupsToSidebarCardElements(tutorialGroups: TutorialGroup[]) {
         return tutorialGroups.map((tutorialGroup) => this.mapTutorialGroupToSidebarCardElement(tutorialGroup));
     }
 
diff --git a/src/main/webapp/i18n/de/iris.json b/src/main/webapp/i18n/de/iris.json
index 70627d2052c0..1f302a833001 100644
--- a/src/main/webapp/i18n/de/iris.json
+++ b/src/main/webapp/i18n/de/iris.json
@@ -81,6 +81,25 @@
             },
             "chat": {
                 "helpOffer": "Wie kann ich Dir helfen?"
+            },
+            "ingestionStates": {
+                "loading": "Wird geladen...",
+                "notStarted": "Nicht gestartet",
+                "inProgress": "In Bearbeitung",
+                "done": "Abgeschlossen",
+                "error": "Fehler",
+                "partiallyIngested": "Teilweise abgeschlossen"
+            },
+            "ingestionAlert": {
+                "lectureUnitSuccess": "Vorlesungseinheit Ingestion in Pyris erfolgreich gestartet",
+                "lectureUnitError": "Fehler beim Senden der Vorlesungseinheit an Pyris",
+                "lectureSuccess": "Vorlesung Ingestion in Pyris erfolgreich gestartet",
+                "lectureError": "Fehler beim Senden der Vorlesung an Pyris",
+                "allLecturesSuccess": "Alle Vorlesungen Ingestion in Pyris erfolgreich gestartet",
+                "allLecturesError": "Fehler beim Senden aller Vorlesungen an Pyris",
+                "lectureNotFound": "Vorlesung kann nicht an Pyris gesendet werden, keine Vorlesung mit der angegebenen ID gefunden.",
+                "pyrisUnavailable": "Pyris ist derzeit nicht verfügbar.",
+                "pyrisError": "Ein Fehler ist bei der Kommunikation mit Pyris aufgetreten."
             }
         }
     }
diff --git a/src/main/webapp/i18n/de/lecture.json b/src/main/webapp/i18n/de/lecture.json
index cfe674a84872..e5ecd6649b38 100644
--- a/src/main/webapp/i18n/de/lecture.json
+++ b/src/main/webapp/i18n/de/lecture.json
@@ -31,6 +31,7 @@
             "endDate": "Ende",
             "visibleDate": "Sichtbar ab",
             "course": "Kurs",
+            "ingestionState": "Vorlesungsimport Zustand in Pyris",
             "detail": {
                 "title": "Vorlesung",
                 "sections": {
diff --git a/src/main/webapp/i18n/en/iris.json b/src/main/webapp/i18n/en/iris.json
index d3ba981c4419..65f153b89c54 100644
--- a/src/main/webapp/i18n/en/iris.json
+++ b/src/main/webapp/i18n/en/iris.json
@@ -81,6 +81,25 @@
             },
             "chat": {
                 "helpOffer": "How can I help you today?"
+            },
+            "ingestionStates": {
+                "loading": "Loading",
+                "notStarted": "Not started",
+                "inProgress": "In progress",
+                "done": "Done",
+                "error": "Error",
+                "partiallyIngested": "Partially ingested"
+            },
+            "ingestionAlert": {
+                "lectureUnitSuccess": "Lecture unit ingestion in Pyris started successfully",
+                "lectureUnitError": "Error while sending lecture unit to Pyris",
+                "lectureSuccess": "Lecture ingestion in Pyris started successfully",
+                "lectureError": "Error while sending lecture to Pyris",
+                "allLecturesSuccess": "All lectures ingestion in Pyris started successfully",
+                "allLecturesError": "Error while sending all lectures to Pyris",
+                "lectureNotFound": "Could not send lecture to Iris, no lecture found with the provided id.",
+                "pyrisUnavailable": "Pyris is currently unavailable.",
+                "pyrisError": "An error occurred while getting ingestion state from Pyris."
             }
         }
     }
diff --git a/src/main/webapp/i18n/en/lecture.json b/src/main/webapp/i18n/en/lecture.json
index 79525529f4c5..284c7d83ace3 100644
--- a/src/main/webapp/i18n/en/lecture.json
+++ b/src/main/webapp/i18n/en/lecture.json
@@ -31,6 +31,7 @@
             "endDate": "End Date",
             "visibleDate": "Visible from",
             "course": "Course",
+            "ingestionState": "Ingestion State",
             "detail": {
                 "title": "Lecture",
                 "sections": {
diff --git a/src/test/java/de/tum/cit/aet/artemis/core/connector/IrisRequestMockProvider.java b/src/test/java/de/tum/cit/aet/artemis/core/connector/IrisRequestMockProvider.java
index 3d394d2c9734..4bee55d7481b 100644
--- a/src/test/java/de/tum/cit/aet/artemis/core/connector/IrisRequestMockProvider.java
+++ b/src/test/java/de/tum/cit/aet/artemis/core/connector/IrisRequestMockProvider.java
@@ -137,6 +137,15 @@ public void mockIngestionWebhookRunResponse(Consumer<PyrisWebhookLectureIngestio
         });
     }
 
+    public void mockDeletionWebhookRunResponse(Consumer<PyrisWebhookLectureIngestionExecutionDTO> responseConsumer) {
+        mockServer.expect(ExpectedCount.once(), requestTo(webhooksApiURL + "/lectures/delete")).andExpect(method(HttpMethod.POST)).andRespond(request -> {
+            var mockRequest = (MockClientHttpRequest) request;
+            var dto = mapper.readValue(mockRequest.getBodyAsString(), PyrisWebhookLectureIngestionExecutionDTO.class);
+            responseConsumer.accept(dto);
+            return MockRestResponseCreators.withRawStatus(HttpStatus.ACCEPTED.value()).createResponse(request);
+        });
+    }
+
     public void mockRunError(int httpStatus) {
         // @formatter:off
         mockServer
@@ -155,6 +164,15 @@ public void mockIngestionWebhookRunError(int httpStatus) {
         // @formatter:on
     }
 
+    public void mockDeletionWebhookRunError(int httpStatus) {
+        // @formatter:off
+        mockServer
+            .expect(ExpectedCount.once(), requestTo(webhooksApiURL + "/lectures/delete"))
+            .andExpect(method(HttpMethod.POST))
+            .andRespond(withStatus(HttpStatus.valueOf(httpStatus)));
+        // @formatter:on
+    }
+
     public void mockVariantsResponse(IrisSubSettingsType feature) throws JsonProcessingException {
         var irisModelDTO = new PyrisVariantDTO("TEST_MODEL", "Test model", "Test description");
         var irisModelDTOArray = new PyrisVariantDTO[] { irisModelDTO };
diff --git a/src/test/java/de/tum/cit/aet/artemis/iris/PyrisConnectorServiceTest.java b/src/test/java/de/tum/cit/aet/artemis/iris/PyrisConnectorServiceTest.java
index de726729a035..a2a6c28aa6c3 100644
--- a/src/test/java/de/tum/cit/aet/artemis/iris/PyrisConnectorServiceTest.java
+++ b/src/test/java/de/tum/cit/aet/artemis/iris/PyrisConnectorServiceTest.java
@@ -3,6 +3,7 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
+import java.util.List;
 import java.util.stream.Stream;
 
 import org.junit.jupiter.params.ParameterizedTest;
@@ -16,6 +17,8 @@
 import de.tum.cit.aet.artemis.iris.exception.IrisInternalPyrisErrorException;
 import de.tum.cit.aet.artemis.iris.service.pyris.PyrisConnectorException;
 import de.tum.cit.aet.artemis.iris.service.pyris.PyrisConnectorService;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisLectureUnitWebhookDTO;
+import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisWebhookLectureIngestionExecutionDTO;
 
 class PyrisConnectorServiceTest extends AbstractIrisIntegrationTest {
 
@@ -47,7 +50,17 @@ void testExceptionV2(int httpStatus, Class<?> exceptionClass) {
     @MethodSource("irisExceptions")
     void testExceptionIngestionV2(int httpStatus, Class<?> exceptionClass) {
         irisRequestMockProvider.mockIngestionWebhookRunError(httpStatus);
-        assertThatThrownBy(() -> pyrisConnectorService.executeLectureWebhook("fullIngestion", null)).isInstanceOf(exceptionClass);
+        PyrisLectureUnitWebhookDTO pyrisLectureUnitWebhookDTO = new PyrisLectureUnitWebhookDTO("example.pdf", 123L, "Lecture Unit Name", 456L, "Lecture Name", 789L, "Course Name",
+                "Course Description");
+        PyrisWebhookLectureIngestionExecutionDTO executionDTO = new PyrisWebhookLectureIngestionExecutionDTO(pyrisLectureUnitWebhookDTO, null, List.of());
+        assertThatThrownBy(() -> pyrisConnectorService.executeLectureAddtionWebhook("fullIngestion", executionDTO)).isInstanceOf(exceptionClass);
+    }
+
+    @ParameterizedTest
+    @MethodSource("irisExceptions")
+    void testExceptionLectureDeletionV2(int httpStatus, Class<?> exceptionClass) {
+        irisRequestMockProvider.mockDeletionWebhookRunError(httpStatus);
+        assertThatThrownBy(() -> pyrisConnectorService.executeLectureDeletionWebhook(null)).isInstanceOf(exceptionClass);
     }
 
     @ParameterizedTest
diff --git a/src/test/java/de/tum/cit/aet/artemis/iris/PyrisLectureIngestionTest.java b/src/test/java/de/tum/cit/aet/artemis/iris/PyrisLectureIngestionTest.java
index e7cdc125faa8..636d18003de1 100644
--- a/src/test/java/de/tum/cit/aet/artemis/iris/PyrisLectureIngestionTest.java
+++ b/src/test/java/de/tum/cit/aet/artemis/iris/PyrisLectureIngestionTest.java
@@ -26,9 +26,12 @@
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.lectureingestionwebhook.PyrisLectureIngestionStatusUpdateDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageDTO;
 import de.tum.cit.aet.artemis.iris.service.pyris.dto.status.PyrisStageState;
+import de.tum.cit.aet.artemis.lecture.domain.Attachment;
 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.repository.LectureRepository;
+import de.tum.cit.aet.artemis.lecture.repository.LectureUnitRepository;
+import de.tum.cit.aet.artemis.lecture.util.LectureFactory;
 import de.tum.cit.aet.artemis.lecture.util.LectureUtilService;
 
 class PyrisLectureIngestionTest extends AbstractIrisIntegrationTest {
@@ -59,6 +62,11 @@ class PyrisLectureIngestionTest extends AbstractIrisIntegrationTest {
     @Autowired
     protected IrisSettingsRepository irisSettingsRepository;
 
+    @Autowired
+    protected LectureUnitRepository lectureUnitRepository;
+
+    private Attachment attachment;
+
     private Lecture lecture1;
 
     @BeforeEach
@@ -83,7 +91,13 @@ void initTestCase() throws Exception {
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
-    void testAutoUpdateAttachmentUnitsWithAutoUpdateEnabled() {
+    void autoIngestionWhenAttachmentUnitCreatedAndAutoUpdateEnabled() {
+        this.attachment = LectureFactory.generateAttachment(null);
+        this.attachment.setName("          LoremIpsum              ");
+        this.attachment.setLink("/api/files/temp/example.txt");
+        this.lecture1 = lectureUtilService.createCourseWithLecture(true);
+        AttachmentUnit attachmentUnit = new AttachmentUnit();
+        attachmentUnit.setDescription("Lorem Ipsum");
         activateIrisFor(lecture1.getCourse());
         IrisCourseSettings courseSettings = irisSettingsService.getRawIrisSettingsFor(lecture1.getCourse());
         courseSettings.getIrisLectureIngestionSettings().setAutoIngestOnLectureAttachmentUpload(true);
@@ -91,65 +105,40 @@ void testAutoUpdateAttachmentUnitsWithAutoUpdateEnabled() {
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        assertThat(pyrisWebhookService.autoUpdateAttachmentUnitsInPyris(lecture1.getCourse().getId(), List.of((AttachmentUnit) lecture1.getLectureUnits().getFirst()))).isTrue();
-        assertThat(pyrisWebhookService.autoUpdateAttachmentUnitsInPyris(lecture1.getCourse().getId(), List.of((AttachmentUnit) lecture1.getLectureUnits().getLast()))).isFalse();
     }
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
-    void testAutoUpdateAttachmentUnitsWithAutoUpdateDisabled() {
-        activateIrisFor(lecture1.getCourse());
-        IrisCourseSettings courseSettings = irisSettingsService.getRawIrisSettingsFor(lecture1.getCourse());
-        courseSettings.getIrisLectureIngestionSettings().setAutoIngestOnLectureAttachmentUpload(false);
-        this.irisSettingsRepository.save(courseSettings);
+    void noAutoIngestionWhenAttachmentUnitCreatedAndAutoUpdateDisabled() {
+        this.attachment = LectureFactory.generateAttachment(null);
+        this.attachment.setName("          LoremIpsum              ");
+        this.attachment.setLink("/api/files/temp/example.txt");
+        this.lecture1 = lectureUtilService.createCourseWithLecture(true);
+        AttachmentUnit attachmentUnit = new AttachmentUnit();
+        attachmentUnit.setDescription("Lorem Ipsum");
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        assertThat(pyrisWebhookService.autoUpdateAttachmentUnitsInPyris(lecture1.getCourse().getId(), List.of((AttachmentUnit) lecture1.getLectureUnits().getFirst()))).isFalse();
-        assertThat(pyrisWebhookService.autoUpdateAttachmentUnitsInPyris(lecture1.getCourse().getId(), List.of((AttachmentUnit) lecture1.getLectureUnits().getLast()))).isFalse();
     }
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
-    void testAddLectureToPyrisDatabaseWithCourseSettingsDisabled() {
+    void testIngestLecturesButtonInPyris() throws Exception {
         activateIrisFor(lecture1.getCourse());
-        IrisCourseSettings courseSettings = irisSettingsService.getRawIrisSettingsFor(lecture1.getCourse());
-        courseSettings.getIrisLectureIngestionSettings().setEnabled(false);
-        this.irisSettingsRepository.save(courseSettings);
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        String jobToken = pyrisWebhookService.addLectureUnitsToPyrisDB(List.of((AttachmentUnit) lecture1.getLectureUnits().getFirst()));
-        assertThat(jobToken).isNull();
-        jobToken = pyrisWebhookService.addLectureUnitsToPyrisDB(List.of((AttachmentUnit) lecture1.getLectureUnits().getLast()));
-        assertThat(jobToken).isNull();
+        request.postWithResponseBody("/api/courses/" + lecture1.getCourse().getId() + "/ingest", Optional.empty(), boolean.class, HttpStatus.OK);
     }
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
-    void testDeleteLecturefromPyrisDatabaseWithCourseSettingsDisabled() {
+    void testIngestLectureUnitButtonInPyris() {
         activateIrisFor(lecture1.getCourse());
-        IrisCourseSettings courseSettings = irisSettingsService.getRawIrisSettingsFor(lecture1.getCourse());
-        courseSettings.getIrisLectureIngestionSettings().setEnabled(false);
-        this.irisSettingsRepository.save(courseSettings);
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        String jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of((AttachmentUnit) lecture1.getLectureUnits().getFirst()));
-        assertThat(jobToken).isNotNull();
-        jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of((AttachmentUnit) lecture1.getLectureUnits().getLast()));
-        assertThat(jobToken).isNull();
-    }
 
-    @Test
-    @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
-    void testIngestLecturesButtonInPyris() throws Exception {
-        activateIrisFor(lecture1.getCourse());
-        irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
-            assertThat(dto.settings().authenticationToken()).isNotNull();
-        });
-        Boolean response = request.postWithResponseBody("/api/courses/" + lecture1.getCourse().getId() + "/ingest", Optional.empty(), boolean.class, HttpStatus.OK);
-        assertThat(response).isTrue();
     }
 
     @Test
@@ -158,7 +147,7 @@ void testDeleteLecturefromPyrisDatabaseWithCourseSettingsEnabled() {
         activateIrisFor(lecture1.getCourse());
         IrisCourseSettings courseSettings = irisSettingsService.getRawIrisSettingsFor(lecture1.getCourse());
         this.irisSettingsRepository.save(courseSettings);
-        irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
+        irisRequestMockProvider.mockDeletionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
         String jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of((AttachmentUnit) lecture1.getLectureUnits().getFirst()));
@@ -169,31 +158,28 @@ void testDeleteLecturefromPyrisDatabaseWithCourseSettingsEnabled() {
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
-    void testAddLectureToPyrisDBAddJobWithCourseSettingsEnabled() {
+    void testAddLectureToPyrisDBAddJobWithCourseSettingsEnabled() throws Exception {
         activateIrisFor(lecture1.getCourse());
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        String jobToken = pyrisWebhookService.addLectureUnitsToPyrisDB(List.of((AttachmentUnit) lecture1.getLectureUnits().getFirst()));
-        assertThat(jobToken).isNotNull();
-        jobToken = pyrisWebhookService.addLectureUnitsToPyrisDB(List.of((AttachmentUnit) lecture1.getLectureUnits().getLast()));
-        assertThat(jobToken).isNull();
+        request.postWithResponseBody("/api/courses/" + lecture1.getCourse().getId() + "/ingest", Optional.empty(), boolean.class, HttpStatus.OK);
     }
 
     @Test
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
-    void testAllStagesDoneRemovesAdditionIngestionJob() throws Exception {
+    void testAllStagesDoneIngestionStateDone() throws Exception {
         activateIrisFor(lecture1.getCourse());
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit attachmentUnit) {
-            String jobToken = pyrisWebhookService.addLectureUnitsToPyrisDB(List.of(attachmentUnit));
+        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit unit) {
+            String jobToken = pyrisWebhookService.addLectureUnitToPyrisDB(unit);
             PyrisStageDTO doneStage = new PyrisStageDTO("done", 1, PyrisStageState.DONE, "Stage completed successfully.");
-            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(doneStage));
+            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(doneStage),
+                    lecture1.getLectureUnits().getFirst().getId());
             var headers = new HttpHeaders(new LinkedMultiValueMap<>(Map.of("Authorization", List.of("Bearer " + jobToken))));
             request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + jobToken + "/status", statusUpdate, HttpStatus.OK, headers);
-            assertThat(pyrisJobService.getJob(jobToken)).isNull();
         }
     }
 
@@ -201,13 +187,14 @@ void testAllStagesDoneRemovesAdditionIngestionJob() throws Exception {
     @WithMockUser(username = TEST_PREFIX + "instructor1", roles = "INSTRUCTOR")
     void testAllStagesDoneRemovesDeletionIngestionJob() throws Exception {
         activateIrisFor(lecture1.getCourse());
-        irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
+        irisRequestMockProvider.mockDeletionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit attachmentUnit) {
-            String jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of(attachmentUnit));
+        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit unit) {
+            String jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of(unit));
             PyrisStageDTO doneStage = new PyrisStageDTO("done", 1, PyrisStageState.DONE, "Stage completed successfully.");
-            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(doneStage));
+            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(doneStage),
+                    lecture1.getLectureUnits().getFirst().getId());
             var headers = new HttpHeaders(new LinkedMultiValueMap<>(Map.of("Authorization", List.of("Bearer " + jobToken))));
             request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + jobToken + "/status", statusUpdate, HttpStatus.OK, headers);
             assertThat(pyrisJobService.getJob(jobToken)).isNull();
@@ -220,11 +207,12 @@ void testStageNotDoneKeepsAdditionIngestionJob() throws Exception {
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit attachmentUnit) {
-            String jobToken = pyrisWebhookService.addLectureUnitsToPyrisDB(List.of(attachmentUnit));
+        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit unit) {
+            String jobToken = pyrisWebhookService.addLectureUnitToPyrisDB(unit);
             PyrisStageDTO doneStage = new PyrisStageDTO("done", 1, PyrisStageState.DONE, "Stage completed successfully.");
             PyrisStageDTO inProgressStage = new PyrisStageDTO("inProgressStage", 1, PyrisStageState.IN_PROGRESS, "Stage completed successfully.");
-            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(doneStage, inProgressStage));
+            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(doneStage, inProgressStage),
+                    lecture1.getLectureUnits().getFirst().getId());
             var headers = new HttpHeaders(new LinkedMultiValueMap<>(Map.of("Authorization", List.of("Bearer " + jobToken))));
             request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + jobToken + "/status", statusUpdate, HttpStatus.OK, headers);
             assertThat(pyrisJobService.getJob(jobToken)).isNotNull();
@@ -232,16 +220,17 @@ void testStageNotDoneKeepsAdditionIngestionJob() throws Exception {
     }
 
     @Test
-    void testStageNotDoneKeepsDeletionIngetionJob() throws Exception {
+    void testStageNotDoneKeepsDeletionIngestionJob() throws Exception {
         activateIrisFor(lecture1.getCourse());
-        irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
+        irisRequestMockProvider.mockDeletionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit attachmentUnit) {
-            String jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of(attachmentUnit));
+        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit unit) {
+            String jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of(unit));
             PyrisStageDTO doneStage = new PyrisStageDTO("done", 1, PyrisStageState.DONE, "Stage completed successfully.");
             PyrisStageDTO inProgressStage = new PyrisStageDTO("inProgressStage", 1, PyrisStageState.IN_PROGRESS, "Stage completed successfully.");
-            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(doneStage, inProgressStage));
+            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(doneStage, inProgressStage),
+                    lecture1.getLectureUnits().getFirst().getId());
             var headers = new HttpHeaders(new LinkedMultiValueMap<>(Map.of("Authorization", List.of("Bearer " + jobToken))));
             request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + jobToken + "/status", statusUpdate, HttpStatus.OK, headers);
             assertThat(pyrisJobService.getJob(jobToken)).isNotNull();
@@ -249,15 +238,16 @@ void testStageNotDoneKeepsDeletionIngetionJob() throws Exception {
     }
 
     @Test
-    void testErrorStageRemovesDeletionIngetionJob() throws Exception {
+    void testErrorStageRemovesDeletionIngestionJob() throws Exception {
         activateIrisFor(lecture1.getCourse());
-        irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
+        irisRequestMockProvider.mockDeletionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit attachmentUnit) {
-            String jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of(attachmentUnit));
+        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit unit) {
+            String jobToken = pyrisWebhookService.deleteLectureFromPyrisDB(List.of(unit));
             PyrisStageDTO errorStage = new PyrisStageDTO("error", 1, PyrisStageState.ERROR, "Stage not broke due to error.");
-            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(errorStage));
+            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(errorStage),
+                    lecture1.getLectureUnits().getFirst().getId());
             var headers = new HttpHeaders(new LinkedMultiValueMap<>(Map.of("Authorization", List.of("Bearer " + jobToken))));
             request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + jobToken + "/status", statusUpdate, HttpStatus.OK, headers);
             assertThat(pyrisJobService.getJob(jobToken)).isNull();
@@ -265,15 +255,16 @@ void testErrorStageRemovesDeletionIngetionJob() throws Exception {
     }
 
     @Test
-    void testErrorStageRemovesAdditionIngetionJob() throws Exception {
+    void testErrorStageRemovesAdditionIngestionJob() throws Exception {
         activateIrisFor(lecture1.getCourse());
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit attachmentUnit) {
-            String jobToken = pyrisWebhookService.addLectureUnitsToPyrisDB(List.of(attachmentUnit));
+        if (lecture1.getLectureUnits().getFirst() instanceof AttachmentUnit unit) {
+            String jobToken = pyrisWebhookService.addLectureUnitToPyrisDB(unit);
             PyrisStageDTO errorStage = new PyrisStageDTO("error", 1, PyrisStageState.ERROR, "Stage not broke due to error.");
-            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(errorStage));
+            PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(errorStage),
+                    lecture1.getLectureUnits().getFirst().getId());
             var headers = new HttpHeaders(new LinkedMultiValueMap<>(Map.of("Authorization", List.of("Bearer " + jobToken))));
             request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + jobToken + "/status", statusUpdate, HttpStatus.OK, headers);
             assertThat(pyrisJobService.getJob(jobToken)).isNull();
@@ -286,10 +277,28 @@ void testRunIdIngestionJob() throws Exception {
         irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
             assertThat(dto.settings().authenticationToken()).isNotNull();
         });
-        String newJobToken = pyrisJobService.addIngestionWebhookJob();
+        String newJobToken = pyrisJobService.addIngestionWebhookJob(123L, lecture1.getId(), lecture1.getLectureUnits().getFirst().getId());
+        String chatJobToken = pyrisJobService.addCourseChatJob(123L, 123L);
+        PyrisStageDTO errorStage = new PyrisStageDTO("error", 1, PyrisStageState.ERROR, "Stage not broke due to error.");
+        PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(errorStage), lecture1.getLectureUnits().getFirst().getId());
+        var headers = new HttpHeaders(new LinkedMultiValueMap<>(Map.of("Authorization", List.of("Bearer " + chatJobToken))));
+        MockHttpServletResponse response = request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + newJobToken + "/status", statusUpdate,
+                HttpStatus.CONFLICT, headers);
+        assertThat(response.getContentAsString()).contains("Run ID in URL does not match run ID in request body");
+        response = request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + chatJobToken + "/status", statusUpdate, HttpStatus.CONFLICT, headers);
+        assertThat(response.getContentAsString()).contains("Run ID is not an ingestion job");
+    }
+
+    @Test
+    void testIngestionJobDone() throws Exception {
+        activateIrisFor(lecture1.getCourse());
+        irisRequestMockProvider.mockIngestionWebhookRunResponse(dto -> {
+            assertThat(dto.settings().authenticationToken()).isNotNull();
+        });
+        String newJobToken = pyrisJobService.addIngestionWebhookJob(123L, lecture1.getId(), lecture1.getLectureUnits().getFirst().getId());
         String chatJobToken = pyrisJobService.addCourseChatJob(123L, 123L);
         PyrisStageDTO errorStage = new PyrisStageDTO("error", 1, PyrisStageState.ERROR, "Stage not broke due to error.");
-        PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(errorStage));
+        PyrisLectureIngestionStatusUpdateDTO statusUpdate = new PyrisLectureIngestionStatusUpdateDTO("Success", List.of(errorStage), lecture1.getLectureUnits().getFirst().getId());
         var headers = new HttpHeaders(new LinkedMultiValueMap<>(Map.of("Authorization", List.of("Bearer " + chatJobToken))));
         MockHttpServletResponse response = request.postWithoutResponseBody("/api/public/pyris/webhooks/ingestion/runs/" + newJobToken + "/status", statusUpdate,
                 HttpStatus.CONFLICT, headers);
diff --git a/src/test/javascript/spec/component/lecture-unit/lecture-unit-management.component.spec.ts b/src/test/javascript/spec/component/lecture-unit/lecture-unit-management.component.spec.ts
index bad4cf68f981..1be7baf22145 100644
--- a/src/test/javascript/spec/component/lecture-unit/lecture-unit-management.component.spec.ts
+++ b/src/test/javascript/spec/component/lecture-unit/lecture-unit-management.component.spec.ts
@@ -1,6 +1,6 @@
 import { ComponentFixture, TestBed } from '@angular/core/testing';
 import { LectureUnitManagementComponent } from 'app/lecture/lecture-unit/lecture-unit-management/lecture-unit-management.component';
-import { AttachmentUnit } from 'app/entities/lecture-unit/attachmentUnit.model';
+import { AttachmentUnit, IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 import { ArtemisTranslatePipe } from 'app/shared/pipes/artemis-translate.pipe';
 import { ExerciseUnit } from 'app/entities/lecture-unit/exerciseUnit.model';
 import { MockComponent, MockDirective, MockPipe, MockProvider } from 'ng-mocks';
@@ -21,10 +21,10 @@ import { Lecture } from 'app/entities/lecture.model';
 import { HttpResponse } from '@angular/common/http';
 import { DeleteButtonDirective } from 'app/shared/delete-dialog/delete-button.directive';
 import { HasAnyAuthorityDirective } from 'app/shared/auth/has-any-authority.directive';
-import { of } from 'rxjs';
+import { of, throwError } from 'rxjs';
 import { By } from '@angular/platform-browser';
 import { ActionType } from 'app/shared/delete-dialog/delete-dialog.model';
-import { Competency } from 'app/entities/competency.model';
+import { CompetencyLectureUnitLink } from 'app/entities/competency.model';
 import { UnitCreationCardComponent } from 'app/lecture/lecture-unit/lecture-unit-management/unit-creation-card/unit-creation-card.component';
 import { ArtemisDatePipe } from 'app/shared/pipes/artemis-date.pipe';
 import { MockRouterLinkDirective } from '../../helpers/mocks/directive/mock-router-link.directive';
@@ -32,13 +32,20 @@ import { LectureUnit, LectureUnitType } from 'app/entities/lecture-unit/lectureU
 import { CdkDragDrop } from '@angular/cdk/drag-drop';
 import { NgbTooltip } from '@ng-bootstrap/ng-bootstrap';
 import { OnlineUnit } from 'app/entities/lecture-unit/onlineUnit.model';
+import { IrisSettingsService } from 'app/iris/settings/shared/iris-settings.service';
+import { ProfileService } from 'app/shared/layouts/profiles/profile.service';
+import { PROFILE_IRIS } from 'app/app.constants';
+import { ProfileInfo } from 'app/shared/layouts/profiles/profile-info.model';
+import { IrisCourseSettings } from 'app/entities/iris/settings/iris-settings.model';
+import { IrisLectureIngestionSubSettings } from 'app/entities/iris/settings/iris-sub-settings.model';
+import { Course } from 'app/entities/course.model';
 
 @Component({ selector: 'jhi-competencies-popover', template: '' })
 class CompetenciesPopoverStubComponent {
     @Input()
     courseId: number;
     @Input()
-    competencies: Competency[] = [];
+    competencyLinks: CompetencyLectureUnitLink[] = [];
     @Input()
     navigateTo: 'competencyManagement' | 'courseStatistics' = 'courseStatistics';
 }
@@ -49,16 +56,21 @@ describe('LectureUnitManagementComponent', () => {
 
     let lectureService: LectureService;
     let lectureUnitService: LectureUnitService;
+    let profileService: ProfileService;
+    let irisSettingsService: IrisSettingsService;
     let findLectureSpy: jest.SpyInstance;
     let findLectureWithDetailsSpy: jest.SpyInstance;
     let deleteLectureUnitSpy: jest.SpyInstance;
     let updateOrderSpy: jest.SpyInstance;
+    let getProfileInfo: jest.SpyInstance;
+    let getCombinedCourseSettings: jest.SpyInstance;
 
     let attachmentUnit: AttachmentUnit;
     let exerciseUnit: ExerciseUnit;
     let textUnit: TextUnit;
     let videoUnit: VideoUnit;
     let lecture: Lecture;
+    let course: Course;
 
     beforeEach(() => {
         return TestBed.configureTestingModule({
@@ -82,6 +94,8 @@ describe('LectureUnitManagementComponent', () => {
                 MockProvider(LectureUnitService),
                 MockProvider(LectureService),
                 MockProvider(AlertService),
+                MockProvider(ProfileService),
+                MockProvider(IrisSettingsService),
                 { provide: Router, useClass: MockRouter },
                 {
                     provide: ActivatedRoute,
@@ -105,11 +119,15 @@ describe('LectureUnitManagementComponent', () => {
                 lectureUnitManagementComponent = lectureUnitManagementComponentFixture.componentInstance;
                 lectureService = TestBed.inject(LectureService);
                 lectureUnitService = TestBed.inject(LectureUnitService);
+                profileService = TestBed.inject(ProfileService);
+                irisSettingsService = TestBed.inject(IrisSettingsService);
 
                 findLectureSpy = jest.spyOn(lectureService, 'find');
                 findLectureWithDetailsSpy = jest.spyOn(lectureService, 'findWithDetails');
                 deleteLectureUnitSpy = jest.spyOn(lectureUnitService, 'delete');
                 updateOrderSpy = jest.spyOn(lectureUnitService, 'updateOrder');
+                getProfileInfo = jest.spyOn(profileService, 'getProfileInfo');
+                getCombinedCourseSettings = jest.spyOn(irisSettingsService, 'getCombinedCourseSettings');
 
                 textUnit = new TextUnit();
                 textUnit.id = 0;
@@ -119,9 +137,12 @@ describe('LectureUnitManagementComponent', () => {
                 exerciseUnit.id = 2;
                 attachmentUnit = new AttachmentUnit();
                 attachmentUnit.id = 3;
+                course = new Course();
+                course.id = 99;
 
                 lecture = new Lecture();
                 lecture.id = 0;
+                lecture.course = course;
                 lecture.lectureUnits = [textUnit, videoUnit, exerciseUnit, attachmentUnit];
 
                 const returnValue = of(new HttpResponse({ body: lecture, status: 200 }));
@@ -129,6 +150,12 @@ describe('LectureUnitManagementComponent', () => {
                 findLectureWithDetailsSpy.mockReturnValue(returnValue);
                 updateOrderSpy.mockReturnValue(returnValue);
                 deleteLectureUnitSpy.mockReturnValue(of(new HttpResponse({ body: videoUnit, status: 200 })));
+                const profileInfo = { activeProfiles: [PROFILE_IRIS] } as ProfileInfo;
+                getProfileInfo.mockReturnValue(of(profileInfo));
+                const irisCourseSettings = new IrisCourseSettings();
+                irisCourseSettings.irisLectureIngestionSettings = new IrisLectureIngestionSubSettings();
+                irisCourseSettings.irisLectureIngestionSettings.enabled = true;
+                getCombinedCourseSettings.mockReturnValue(of(irisCourseSettings));
 
                 lectureUnitManagementComponentFixture.detectChanges();
             });
@@ -201,6 +228,59 @@ describe('LectureUnitManagementComponent', () => {
         expect(lectureUnitManagementComponent.getActionType(new OnlineUnit())).toEqual(ActionType.Delete);
     });
 
+    it('should call onIngestButtonClicked when button is clicked', () => {
+        const ingestLectureUnitInPyris = jest.spyOn(lectureUnitService, 'ingestLectureUnitInPyris');
+        const returnValue = of(new HttpResponse<void>({ status: 200 }));
+        ingestLectureUnitInPyris.mockReturnValue(returnValue);
+        const lectureUnitId = 1;
+        lectureUnitManagementComponent.lecture = { id: 2 } as any;
+        lectureUnitManagementComponent.onIngestButtonClicked(lectureUnitId);
+        expect(lectureUnitService.ingestLectureUnitInPyris).toHaveBeenCalledWith(lectureUnitId, lectureUnitManagementComponent.lecture.id);
+    });
+
+    it('should initialize profile info and check for Iris settings', () => {
+        lectureUnitManagementComponent.lecture = lecture;
+        lectureUnitManagementComponent.initializeProfileInfo();
+        expect(profileService.getProfileInfo).toHaveBeenCalled();
+        expect(irisSettingsService.getCombinedCourseSettings).toHaveBeenCalledWith(lecture.course!.id);
+        expect(lectureUnitManagementComponent.irisEnabled).toBeTrue();
+        expect(lectureUnitManagementComponent.lectureIngestionEnabled).toBeTrue();
+    });
+
+    it('should update ingestion states correctly when getIngestionState returns data', () => {
+        lectureUnitManagementComponent.lecture = lecture;
+        const mockIngestionStates = {
+            3: IngestionState.DONE,
+        };
+
+        jest.spyOn(lectureUnitService, 'getIngestionState').mockReturnValue(
+            of(
+                new HttpResponse({
+                    body: mockIngestionStates,
+                    status: 200,
+                }),
+            ),
+        );
+        lectureUnitManagementComponent.updateIngestionStates();
+        expect(lectureUnitService.getIngestionState).toHaveBeenCalledWith(lecture.course!.id!, lecture.id);
+        expect(attachmentUnit.pyrisIngestionState).toBe(IngestionState.DONE);
+    });
+
+    it('should handle error when ingestLectureUnitInPyris fails', () => {
+        const ingestLectureUnitInPyris = jest.spyOn(lectureUnitService, 'ingestLectureUnitInPyris');
+        const lectureUnitId = 1;
+        lectureUnitManagementComponent.lecture = { id: 2 } as any;
+        const error = new Error('Failed to send Ingestion request');
+        ingestLectureUnitInPyris.mockReturnValue(throwError(() => error));
+
+        jest.spyOn(console, 'error').mockImplementation(() => {});
+
+        lectureUnitManagementComponent.onIngestButtonClicked(lectureUnitId);
+
+        expect(lectureUnitService.ingestLectureUnitInPyris).toHaveBeenCalledWith(lectureUnitId, lectureUnitManagementComponent.lecture.id);
+        expect(console.error).toHaveBeenCalledWith('Failed to send lecture unit ingestion request', error);
+    });
+
     describe('isViewButtonAvailable', () => {
         it('should return true for an attachment unit with a PDF link', () => {
             const lectureUnit = {
diff --git a/src/test/javascript/spec/component/lecture-unit/lecture-unit.service.spec.ts b/src/test/javascript/spec/component/lecture-unit/lecture-unit.service.spec.ts
index df7b3e171889..3a2a4df89376 100644
--- a/src/test/javascript/spec/component/lecture-unit/lecture-unit.service.spec.ts
+++ b/src/test/javascript/spec/component/lecture-unit/lecture-unit.service.spec.ts
@@ -5,7 +5,7 @@ import { Lecture } from 'app/entities/lecture.model';
 import { LectureUnitService } from 'app/lecture/lecture-unit/lecture-unit-management/lectureUnit.service';
 import { LectureUnit } from 'app/entities/lecture-unit/lectureUnit.model';
 import dayjs from 'dayjs/esm';
-import { AttachmentUnit } from 'app/entities/lecture-unit/attachmentUnit.model';
+import { AttachmentUnit, IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 import { TextUnit } from 'app/entities/lecture-unit/textUnit.model';
 import { VideoUnit } from 'app/entities/lecture-unit/videoUnit.model';
 import { ExerciseUnit } from 'app/entities/lecture-unit/exerciseUnit.model';
@@ -154,4 +154,44 @@ describe('LectureUnitService', () => {
         expect(convertDateFromServerEntitySpy).not.toHaveBeenCalled();
         expect(result).toBe(emptyResponse);
     }));
+
+    it('should fetch the ingestion state for lecture units and return an OK response', () => {
+        const courseId = 123;
+        const lectureId = 456;
+        const expectedUrl = `api/iris/courses/${courseId}/lectures/${lectureId}/lecture-units/ingestion-state`;
+
+        const expectedResponse: Record<number, IngestionState> = {
+            1: IngestionState.DONE,
+            2: IngestionState.NOT_STARTED,
+        };
+
+        service.getIngestionState(courseId, lectureId).subscribe((response) => {
+            expect(response.body).toEqual(expectedResponse);
+        });
+
+        const req = httpMock.expectOne({
+            url: expectedUrl,
+            method: 'GET',
+        });
+
+        req.flush(expectedResponse, { status: 200, statusText: 'OK' });
+
+        expect(req.request.method).toBe('GET');
+    });
+
+    it('should send a POST request to ingest a lecture unit and return an OK response', () => {
+        const lectureUnitId = 123;
+        const lectureId = 456;
+        const expectedUrl = `api/lectures/${lectureId}/lecture-units/${lectureUnitId}/ingest`;
+
+        service.ingestLectureUnitInPyris(lectureUnitId, lectureId).subscribe((response) => {
+            expect(response.status).toBe(200);
+        });
+        const req = httpMock.expectOne({
+            url: expectedUrl,
+            method: 'POST',
+        });
+        req.flush(null, { status: 200, statusText: 'OK' });
+        expect(req.request.method).toBe('POST');
+    });
 });
diff --git a/src/test/javascript/spec/component/lecture/lecture-detail.component.spec.ts b/src/test/javascript/spec/component/lecture/lecture-detail.component.spec.ts
index 367f3d916eff..c4cf5ce89d01 100644
--- a/src/test/javascript/spec/component/lecture/lecture-detail.component.spec.ts
+++ b/src/test/javascript/spec/component/lecture/lecture-detail.component.spec.ts
@@ -101,7 +101,7 @@ describe('LectureDetailComponent', () => {
     });
     it('should call the service to ingest lectures when ingestLecturesInPyris is called', () => {
         component.lecture = mockLecture;
-        const ingestSpy = jest.spyOn(lectureService, 'ingestLecturesInPyris').mockImplementation(() => of(new HttpResponse<boolean>({ status: 200, body: true })));
+        const ingestSpy = jest.spyOn(lectureService, 'ingestLecturesInPyris').mockImplementation(() => of(new HttpResponse<void>({ status: 200 })));
         component.ingestLectureInPyris();
         expect(ingestSpy).toHaveBeenCalledWith(mockLecture.course?.id, mockLecture.id);
         expect(ingestSpy).toHaveBeenCalledOnce();
diff --git a/src/test/javascript/spec/component/lecture/lecture.component.spec.ts b/src/test/javascript/spec/component/lecture/lecture.component.spec.ts
index 62d315dd67e7..da714bd7059e 100644
--- a/src/test/javascript/spec/component/lecture/lecture.component.spec.ts
+++ b/src/test/javascript/spec/component/lecture/lecture.component.spec.ts
@@ -23,18 +23,15 @@ import { LectureImportComponent } from 'app/lecture/lecture-import.component';
 import { DocumentationButtonComponent } from 'app/shared/components/documentation-button/documentation-button.component';
 import { SortDirective } from 'app/shared/sort/sort.directive';
 import { Course } from 'app/entities/course.model';
-import { IrisSettingsService } from 'app/iris/settings/shared/iris-settings.service';
-import { IrisCourseSettings } from 'app/entities/iris/settings/iris-settings.model';
-import { PROFILE_IRIS } from 'app/app.constants';
 import { ProfileInfo } from 'app/shared/layouts/profiles/profile-info.model';
 import { ProfileService } from 'app/shared/layouts/profiles/profile.service';
+import { IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 
 describe('Lecture', () => {
     let lectureComponentFixture: ComponentFixture<LectureComponent>;
     let lectureComponent: LectureComponent;
     let lectureService: LectureService;
     let profileService: ProfileService;
-    let irisSettingsService: IrisSettingsService;
     let modalService: NgbModal;
 
     let pastLecture: Lecture;
@@ -100,6 +97,7 @@ describe('Lecture', () => {
         lectureToIngest.id = 1;
         lectureToIngest.title = 'machine Learning';
         lectureToIngest.course = new Course();
+        lectureToIngest.course.id = 99;
         consoleSpy = jest.spyOn(console, 'error').mockImplementation();
 
         const profileInfo = {
@@ -134,7 +132,7 @@ describe('Lecture', () => {
                     },
                 },
                 MockProvider(LectureService, {
-                    findAllByCourseId: () => {
+                    findAllByCourseIdWithSlides: () => {
                         return of(
                             new HttpResponse({
                                 body: [pastLecture, pastLecture2, currentLecture, currentLecture2, currentLecture3, futureLecture, futureLecture2, unspecifiedLecture],
@@ -172,7 +170,7 @@ describe('Lecture', () => {
     });
 
     it('should fetch lectures when initialized', () => {
-        const findAllSpy = jest.spyOn(lectureService, 'findAllByCourseId');
+        const findAllSpy = jest.spyOn(lectureService, 'findAllByCourseIdWithSlides');
 
         lectureComponentFixture.detectChanges();
 
@@ -265,15 +263,39 @@ describe('Lecture', () => {
 
     it('should call the service to ingest lectures when ingestLecturesInPyris is called', () => {
         lectureComponent.lectures = [lectureToIngest];
-        const ingestSpy = jest.spyOn(lectureService, 'ingestLecturesInPyris').mockImplementation(() => of(new HttpResponse<boolean>({ status: 200, body: true })));
+        const ingestSpy = jest.spyOn(lectureService, 'ingestLecturesInPyris').mockImplementation(() => of(new HttpResponse<void>({ status: 200 })));
         lectureComponent.ingestLecturesInPyris();
         expect(ingestSpy).toHaveBeenCalledWith(lectureToIngest.course?.id);
         expect(ingestSpy).toHaveBeenCalledOnce();
     });
 
+    it('should update ingestion states correctly when getIngestionState returns data', () => {
+        lectureComponent.courseId = 99;
+        lectureComponent.lectures = [lectureToIngest, pastLecture];
+        const mockIngestionStates = {
+            1: IngestionState.DONE,
+            6: IngestionState.PARTIALLY_INGESTED,
+        };
+
+        jest.spyOn(lectureService, 'getIngestionState').mockReturnValue(
+            of(
+                new HttpResponse({
+                    body: mockIngestionStates,
+                    status: 200,
+                }),
+            ),
+        );
+
+        lectureComponent.updateIngestionStates();
+
+        expect(lectureService.getIngestionState).toHaveBeenCalledWith(lectureToIngest.course!.id!);
+        expect(lectureToIngest.ingested).toBe(IngestionState.DONE);
+        expect(pastLecture.ingested).toBe(IngestionState.PARTIALLY_INGESTED);
+    });
+
     it('should not call the service if the first lecture does not exist', () => {
         lectureComponent.lectures = [];
-        const ingestSpy = jest.spyOn(lectureService, 'ingestLecturesInPyris').mockImplementation(() => of(new HttpResponse<boolean>({ status: 200, body: true })));
+        const ingestSpy = jest.spyOn(lectureService, 'ingestLecturesInPyris').mockImplementation(() => of(new HttpResponse<void>({ status: 200 })));
         lectureComponent.ingestLecturesInPyris();
         expect(ingestSpy).not.toHaveBeenCalled();
     });
@@ -281,23 +303,6 @@ describe('Lecture', () => {
         lectureComponent.lectures = [lectureToIngest];
         jest.spyOn(lectureService, 'ingestLecturesInPyris').mockReturnValue(throwError(() => new Error('Error while ingesting')));
         lectureComponent.ingestLecturesInPyris();
-        expect(consoleSpy).toHaveBeenCalledWith('Failed to send Ingestion request', expect.any(Error));
-    });
-    it('should set lectureIngestionEnabled based on service response', () => {
-        irisSettingsService = TestBed.inject(IrisSettingsService);
-        profileService = TestBed.inject(ProfileService);
-        const profileInfoResponse = {
-            activeProfiles: [PROFILE_IRIS],
-        } as ProfileInfo;
-        const irisSettingsResponse = {
-            irisLectureIngestionSettings: {
-                enabled: true,
-            },
-        } as IrisCourseSettings;
-        jest.spyOn(profileService, 'getProfileInfo').mockReturnValue(of(profileInfoResponse));
-        jest.spyOn(irisSettingsService, 'getCombinedCourseSettings').mockImplementation(() => of(irisSettingsResponse));
-        lectureComponent.ngOnInit();
-        expect(irisSettingsService.getCombinedCourseSettings).toHaveBeenCalledWith(lectureComponent.courseId);
-        expect(lectureComponent.lectureIngestionEnabled).toBeTrue();
+        expect(consoleSpy).toHaveBeenCalledWith('Failed to send Lectures Ingestion request', expect.any(Error));
     });
 });
diff --git a/src/test/javascript/spec/service/lecture.service.spec.ts b/src/test/javascript/spec/service/lecture.service.spec.ts
index 681d13f11509..57e6e27c7d64 100644
--- a/src/test/javascript/spec/service/lecture.service.spec.ts
+++ b/src/test/javascript/spec/service/lecture.service.spec.ts
@@ -11,6 +11,7 @@ import { LectureService } from 'app/lecture/lecture.service';
 import { Lecture } from 'app/entities/lecture.model';
 import { Course } from 'app/entities/course.model';
 import dayjs from 'dayjs/esm';
+import { IngestionState } from 'app/entities/lecture-unit/attachmentUnit.model';
 
 describe('Lecture Service', () => {
     let httpMock: HttpTestingController;
@@ -213,6 +214,24 @@ describe('Lecture Service', () => {
             expect(results).toEqual([elemDefault, elemDefault]);
         });
 
+        it('should fetch ingestion state for a course', () => {
+            const courseId = 123;
+            const expectedUrl = `api/iris/courses/${courseId}/lectures/ingestion-state`;
+            const expectedResponse = { 1: IngestionState.DONE, 2: IngestionState.NOT_STARTED };
+
+            service.getIngestionState(courseId).subscribe((resp) => {
+                expect(resp.body).toEqual(expectedResponse);
+            });
+
+            const req = httpMock.expectOne({
+                url: expectedUrl,
+                method: 'GET',
+            });
+
+            req.flush(expectedResponse);
+            expect(req.request.method).toBe('GET');
+        });
+
         it('should send a POST request to ingest lectures and return an OK response', () => {
             const courseId = 123;
             const lectureId = 456;