Feat/opg scanning poc

service-app/internal/api/client.go

@@ -0,0 +1,76 @@
+package api
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/ministryofjustice/opg-scanning/internal/types"
+)
+
+func CreateStubCase(url string, set types.BaseSet) (*types.ScannedCaseResponse, error) {
+	var scannedCaseRequest types.ScannedCaseRequest
+	now := time.Now().Format(time.RFC3339)
+
+	if set.Header.CaseNo == "" {
+		// Check for LPA cases
+		for _, doc := range set.Body.Documents {
+			if doc.Type == "LPA002" || doc.Type == "LP1F" || doc.Type == "LP1H" || doc.Type == "LP2" {
+				// Create a new LPA case
+				scannedCaseRequest = types.ScannedCaseRequest{
+					BatchID:     set.Header.Schedule,
+					CaseType:    "LPA",
+					ReceiptDate: set.Header.ScanTime,
+					CreatedDate: now,
+				}
+				break
+			} else if doc.Type == "EP2PG" || doc.Type == "EPA" {
+				// Create a new EPA case
+				scannedCaseRequest = types.ScannedCaseRequest{
+					BatchID:     set.Header.Schedule,
+					CaseType:    "epa",
+					ReceiptDate: set.Header.ScanTime,
+					CreatedDate: now,
+				}
+				break
+			}
+		}
+	} else if set.Header.CaseNo != "" {
+		// Check for COPORD case with CaseNo
+		for _, doc := range set.Body.Documents {
+			if doc.Type == "COPORD" {
+				scannedCaseRequest = types.ScannedCaseRequest{
+					CourtReference: set.Header.CaseNo,
+					BatchID:        set.Header.Schedule,
+					CaseType:       "order",
+					ReceiptDate:    set.Header.ScanTime,
+				}
+				// Trigger events as per Order::createFromDdc (requires additional implementation)
+				break
+			}
+		}
+	}
+
+	return requestCreateScannedCase(url, scannedCaseRequest)
+}
+
+func requestCreateScannedCase(url string, reqData types.ScannedCaseRequest) (*types.ScannedCaseResponse, error) {
+	body, err := json.Marshal(reqData)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request data: %w", err)
+	}
+
+	req, err := http.NewRequest("POST", url+"/scanned-cases", bytes.NewBuffer(body))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Content-Type", "application/json")
+
+	// Make the request (dummy for testing purposes)
+	// Placeholder for actual HTTP call
+	// resp, err := http.DefaultClient.Do(req)
+	// Instead return a dummy UUID for now
+	return &types.ScannedCaseResponse{UUID: "dummy-uuid-1234"}, nil
+}

service-app/internal/api/handler.go

@@ -1,6 +1,7 @@
 package api
 
 import (
+	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
@@ -68,18 +69,31 @@ func (c *IndexController) IngestHandler(w http.ResponseWriter, r *http.Request)
 		return
 	}
 
-	// Step 4: Queue each document for further processing
+	// Step 4: Create a case stub in Sirius if we have a case to create
+	scannedCaseResponse, err := CreateStubCase(c.config.App.SiriusBaseURL, *parsedBaseXml)
+	if err != nil {
+		c.logger.Error("Failed to create case stub in Sirius: " + err.Error())
+		http.Error(w, "Failed to create case stub in Sirius", http.StatusInternalServerError)
+		return
+	}
+
+	// Step 5: Queue each document for further processing
 	c.logger.Info("Queueing documents for processing")
 	for i := range parsedBaseXml.Body.Documents {
 		doc := &parsedBaseXml.Body.Documents[i]
-		c.Queue.AddToQueue(doc, "xml", func() {
+		c.Queue.AddToQueue(doc, "xml", func(processedDocument interface{}) {
+			c.logger.Info(fmt.Sprintf("%v", processedDocument))
 			c.logger.Info("Job processing completed for document")
 		})
 		c.logger.Info("Job added to queue for document")
 	}
 
+	// Step 6: Send the UUID response
+	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(http.StatusAccepted)
-	c.logger.Info("Ingestion request processed successfully")
+	json.NewEncoder(w).Encode(scannedCaseResponse)
+	c.logger.Info("Ingestion request processed successfully, UUID: " + scannedCaseResponse.UUID)
+
 }
 
 func (c *IndexController) CloseQueue() {
@@ -106,7 +120,7 @@ func (c *IndexController) validateAndSanitizeXML(bodyStr string) (*types.BaseSet
 
 	// Validate against XSD
 	c.logger.Info("Validating against XSD")
-	xsdValidator, err := ingestion.NewXSDValidator(c.config.ProjectFullPath+"/xsd/"+schemaLocation, bodyStr)
+	xsdValidator, err := ingestion.NewXSDValidator(c.config.App.ProjectFullPath+"/xsd/"+schemaLocation, bodyStr)
 	if err != nil {
 		return nil, err
 	}

service-app/internal/api/handler_test.go

@@ -43,7 +43,7 @@ func TestIngestHandler_SetValid(t *testing.T) {
 	controller.IngestHandler(w, req)
 
 	resp := w.Result()
-	if resp.StatusCode != http.StatusAccepted {
+	if resp.StatusCode != http.StatusAccepted { // Expecting 202 for async processing
 		t.Errorf("expected status %d; got %d", http.StatusAccepted, resp.StatusCode)
 	}
 }

service-app/internal/ingestion/job_queue.go

@@ -13,7 +13,7 @@ import (
 type Job struct {
 	Data       *types.BaseDocument
 	format     string
-	onComplete func()
+	onComplete func(interface{})
 }
 
 type JobQueue struct {
@@ -31,7 +31,7 @@ func NewJobQueue() *JobQueue {
 	return queue
 }
 
-func (q *JobQueue) AddToQueue(data *types.BaseDocument, format string, onComplete func()) {
+func (q *JobQueue) AddToQueue(data *types.BaseDocument, format string, onComplete func(interface{})) {
 	job := Job{Data: data, format: format, onComplete: onComplete}
 	q.wg.Add(1)
 	q.Jobs <- job
@@ -62,14 +62,14 @@ func (q *JobQueue) StartWorkerPool(ctx context.Context, numWorkers int) {
 						}
 
 						// Process the document
-						_, err = processor.Process()
+						parsedDoc, err := processor.Process()
 						if err != nil {
 							q.logger.Error("Worker %d failed to process job: %v\n", workerID, err)
 							return
 						}
 
 						if job.onComplete != nil {
-							job.onComplete()
+							job.onComplete(parsedDoc)
 						}
 					}()
 

service-app/internal/ingestion/job_queue_test.go

@@ -38,7 +38,7 @@ func TestJobQueue(t *testing.T) {
 			EmbeddedXML: xml,
 		}
 
-		queue.AddToQueue(doc, "xml", func() {
+		queue.AddToQueue(doc, "xml", func(processedDocument interface{}) {
 			atomic.AddInt32(&processedJobs, 1)
 		})
 	}

service-app/internal/ingestion/set_validator.go

@@ -28,6 +28,7 @@ func (v *Validator) ValidateSet(parsedSet *types.BaseSet) error {
 	if parsedSet.Header == nil {
 		return errors.New("missing required Header element")
 	}
+
 	// if parsedSet.Header.CaseNo == "" {
 	// 	return errors.New("missing CaseNo in Header")
 	// }

service-app/internal/types/client.go

@@ -0,0 +1,22 @@
+package types
+
+type ScannedCaseRequest struct {
+	BatchID        string `json:"batchId"`
+	CaseType       string `json:"caseType"`
+	CourtReference string `json:"courtReference,omitempty"`
+	ReceiptDate    string `json:"receiptDate"`
+	CreatedDate    string `json:"createdDate"`
+}
+
+type ScannedCaseResponse struct {
+	UUID string `json:"uuid"`
+}
+
+// For handling error responses according to the OpenAPI spec
+type ErrorResponse struct {
+	Type             string            `json:"type"`
+	Title            string            `json:"title"`
+	Status           string            `json:"status"`
+	Detail           string            `json:"detail"`
+	ValidationErrors map[string]string `json:"validation_errors"`
+}