feat(continuous_screening): Expose continuous task status

api/handle_continuous_screening.go

@@ -389,6 +389,84 @@ func handleGetContinuousScreeningDelta(uc usecases.Usecases) func(c *gin.Context
 	}
 }
 
+var continuousScreeningUpdateJobsPaginationDefaults = models.PaginationDefaults{
+	Limit:  25,
+	SortBy: models.SortingFieldCreatedAt,
+	Order:  models.SortingOrderDesc,
+}
+
+func handleListContinuousScreeningUpdateJobs(uc usecases.Usecases) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		ctx := c.Request.Context()
+		organizationId, err := utils.OrganizationIdFromRequest(c.Request)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		var paginationAndSortingDto dto.PaginationAndSorting
+		if err := c.ShouldBind(&paginationAndSortingDto); err != nil {
+			c.JSON(http.StatusBadRequest, dto.APIErrorResponse{
+				Message: err.Error(),
+			})
+			return
+		}
+		paginationAndSorting := models.WithPaginationDefaults(
+			dto.AdaptPaginationAndSorting(paginationAndSortingDto),
+			continuousScreeningUpdateJobsPaginationDefaults,
+		)
+
+		uc := usecasesWithCreds(ctx, uc).NewContinuousScreeningUsecase()
+		result, err := uc.ListUpdateJobs(ctx, organizationId, paginationAndSorting)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		c.JSON(http.StatusOK, dto.PaginatedContinuousScreeningUpdateJobs{
+			HasNextPage: result.HasNextPage,
+			Items:       pure_utils.Map(result.Items, dto.AdaptContinuousScreeningUpdateJobDto),
+		})
+	}
+}
+
+var continuousScreeningDeltaTracksPaginationDefaults = models.PaginationDefaults{
+	Limit:  25,
+	SortBy: models.SortingFieldCreatedAt,
+	Order:  models.SortingOrderDesc,
+}
+
+func handleListContinuousScreeningDeltaTracks(uc usecases.Usecases) func(c *gin.Context) {
+	return func(c *gin.Context) {
+		ctx := c.Request.Context()
+		organizationId, err := utils.OrganizationIdFromRequest(c.Request)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		var paginationAndSortingDto dto.PaginationAndSorting
+		if err := c.ShouldBind(&paginationAndSortingDto); err != nil {
+			c.JSON(http.StatusBadRequest, dto.APIErrorResponse{
+				Message: err.Error(),
+			})
+			return
+		}
+		paginationAndSorting := models.WithPaginationDefaults(
+			dto.AdaptPaginationAndSorting(paginationAndSortingDto),
+			continuousScreeningDeltaTracksPaginationDefaults,
+		)
+
+		uc := usecasesWithCreds(ctx, uc).NewContinuousScreeningUsecase()
+		result, err := uc.ListDeltaTracks(ctx, organizationId, paginationAndSorting)
+		if presentError(ctx, c, err) {
+			return
+		}
+
+		c.JSON(http.StatusOK, dto.PaginatedContinuousScreeningDeltaTracks{
+			HasNextPage: result.HasNextPage,
+			Items:       pure_utils.Map(result.Items, dto.AdaptContinuousScreeningDeltaTrackDto),
+		})
+	}
+}
+
 func handleGetContinuousScreeningFull(uc usecases.Usecases) func(c *gin.Context) {
 	return func(c *gin.Context) {
 		ctx := c.Request.Context()

api/routes.go

@@ -219,6 +219,10 @@ func addRoutes(r *gin.Engine, conf Configuration, uc usecases.Usecases, auth uti
 		handleDismissContinuousScreening(uc))
 	router.POST("/continuous-screenings/:id/load-more", tom,
 		handleLoadMoreContinuousScreeningMatches(uc))
+	router.GET("/continuous-screenings/debug/update-jobs", tom,
+		handleListContinuousScreeningUpdateJobs(uc))
+	router.GET("/continuous-screenings/debug/delta-tracks", tom,
+		handleListContinuousScreeningDeltaTracks(uc))
 
 	router.GET("/scenario-publications", tom, handleListScenarioPublications(uc))
 	router.POST("/scenario-publications", tom, handleCreateScenarioPublication(uc))

dto/continuous_screening_dto.go

@@ -89,3 +89,96 @@ func AdaptContinuousScreeningMatchDto(m models.ContinuousScreeningMatch) Continu
 		UpdatedAt:             m.UpdatedAt,
 	}
 }
+
+// Debug endpoints DTOs
+
+type ContinuousScreeningUpdateJobDto struct {
+	Id              uuid.UUID `json:"id"`
+	DatasetUpdateId uuid.UUID `json:"dataset_update_id"`
+	ConfigId        uuid.UUID `json:"config_id"`
+	OrgId           uuid.UUID `json:"org_id"`
+	Status          string    `json:"status"`
+	DatasetName     string    `json:"dataset_name"`
+	DatasetVersion  string    `json:"dataset_version"`
+	TotalItems      int       `json:"total_items"`
+	ItemsProcessed  int       `json:"items_processed"`
+	CreatedAt       time.Time `json:"created_at"`
+	UpdatedAt       time.Time `json:"updated_at"`
+}
+
+func AdaptContinuousScreeningUpdateJobDto(
+	m models.ContinuousScreeningUpdateJobWithProgress,
+) ContinuousScreeningUpdateJobDto {
+	return ContinuousScreeningUpdateJobDto{
+		Id:              m.Id,
+		DatasetUpdateId: m.DatasetUpdateId,
+		ConfigId:        m.ConfigId,
+		OrgId:           m.OrgId,
+		Status:          m.Status.String(),
+		DatasetName:     m.DatasetName,
+		DatasetVersion:  m.DatasetVersion,
+		TotalItems:      m.TotalItems,
+		ItemsProcessed:  m.ItemsProcessed,
+		CreatedAt:       m.CreatedAt,
+		UpdatedAt:       m.UpdatedAt,
+	}
+}
+
+type PaginatedContinuousScreeningUpdateJobs struct {
+	HasNextPage bool                               `json:"has_next_page"`
+	Items       []ContinuousScreeningUpdateJobDto  `json:"items"`
+}
+
+type ContinuousScreeningDatasetFileDto struct {
+	Id        uuid.UUID `json:"id"`
+	FileType  string    `json:"file_type"`
+	Version   string    `json:"version"`
+	CreatedAt time.Time `json:"created_at"`
+}
+
+type ContinuousScreeningDeltaTrackDto struct {
+	Id               uuid.UUID                          `json:"id"`
+	OrgId            uuid.UUID                          `json:"org_id"`
+	ObjectType       string                             `json:"object_type"`
+	ObjectId         string                             `json:"object_id"`
+	ObjectInternalId *uuid.UUID                         `json:"object_internal_id,omitempty"`
+	EntityId         string                             `json:"entity_id"`
+	Operation        string                             `json:"operation"`
+	Processed        bool                               `json:"processed"`
+	DatasetFile      *ContinuousScreeningDatasetFileDto `json:"dataset_file,omitempty"`
+	CreatedAt        time.Time                          `json:"created_at"`
+	UpdatedAt        time.Time                          `json:"updated_at"`
+}
+
+func AdaptContinuousScreeningDeltaTrackDto(
+	m models.ContinuousScreeningDeltaTrackWithFile,
+) ContinuousScreeningDeltaTrackDto {
+	var datasetFileDto *ContinuousScreeningDatasetFileDto
+	if m.DatasetFile != nil {
+		datasetFileDto = &ContinuousScreeningDatasetFileDto{
+			Id:        m.DatasetFile.Id,
+			FileType:  m.DatasetFile.FileType.String(),
+			Version:   m.DatasetFile.Version,
+			CreatedAt: m.DatasetFile.CreatedAt,
+		}
+	}
+
+	return ContinuousScreeningDeltaTrackDto{
+		Id:               m.Id,
+		OrgId:            m.OrgId,
+		ObjectType:       m.ObjectType,
+		ObjectId:         m.ObjectId,
+		ObjectInternalId: m.ObjectInternalId,
+		EntityId:         m.EntityId,
+		Operation:        m.Operation.String(),
+		Processed:        m.DatasetFileId != nil,
+		DatasetFile:      datasetFileDto,
+		CreatedAt:        m.CreatedAt,
+		UpdatedAt:        m.UpdatedAt,
+	}
+}
+
+type PaginatedContinuousScreeningDeltaTracks struct {
+	HasNextPage bool                               `json:"has_next_page"`
+	Items       []ContinuousScreeningDeltaTrackDto `json:"items"`
+}

mocks/continuous_screening_repository.go

@@ -392,6 +392,26 @@ func (m *ContinuousScreeningRepository) GetContinuousScreeningLatestDatasetFileB
 	return args.Get(0).(*models.ContinuousScreeningDatasetFile), args.Error(1)
 }
 
+func (m *ContinuousScreeningRepository) ListContinuousScreeningUpdateJobsByOrgId(
+	ctx context.Context,
+	exec repositories.Executor,
+	orgId uuid.UUID,
+	paginationAndSorting models.PaginationAndSorting,
+) ([]models.ContinuousScreeningUpdateJobWithProgress, error) {
+	args := m.Called(ctx, exec, orgId, paginationAndSorting)
+	return args.Get(0).([]models.ContinuousScreeningUpdateJobWithProgress), args.Error(1)
+}
+
+func (m *ContinuousScreeningRepository) ListContinuousScreeningDeltaTracksByOrgId(
+	ctx context.Context,
+	exec repositories.Executor,
+	orgId uuid.UUID,
+	paginationAndSorting models.PaginationAndSorting,
+) ([]models.ContinuousScreeningDeltaTrackWithFile, error) {
+	args := m.Called(ctx, exec, orgId, paginationAndSorting)
+	return args.Get(0).([]models.ContinuousScreeningDeltaTrackWithFile), args.Error(1)
+}
+
 func (m *ContinuousScreeningRepository) UpdateContinuousScreeningEntityEnrichedPayload(
 	ctx context.Context,
 	exec repositories.Executor,

models/continuous_screening.go

@@ -228,6 +228,19 @@ type EnrichedContinuousScreeningUpdateJob struct {
 	DatasetUpdate ContinuousScreeningDatasetUpdate
 }
 
+type ContinuousScreeningUpdateJobWithProgress struct {
+	ContinuousScreeningUpdateJob
+	DatasetName    string
+	DatasetVersion string
+	TotalItems     int
+	ItemsProcessed int
+}
+
+type ContinuousScreeningDeltaTrackWithFile struct {
+	ContinuousScreeningDeltaTrack
+	DatasetFile *ContinuousScreeningDatasetFile
+}
+
 // ContinuousScreeningJobOffset tracks the progress of processing a dataset update
 type ContinuousScreeningJobOffset struct {
 	Id             uuid.UUID