Add ValidationContext to db

buildingmotif/database/table_connection.py

@@ -11,6 +11,7 @@
     DBModel,
     DBShapeCollection,
     DBTemplate,
+    DBValidationContext,
     DepsAssociation,
 )
 
@@ -536,3 +537,54 @@ def delete_db_template(self, id: int) -> None:
         self.logger.debug(f"Deleting template: '{db_template.name}'")
 
         self.bm.session.delete(db_template)
+
+    def get_all_db_validation_contexts(self) -> List[DBValidationContext]:
+        """Get all database validation contexts.
+
+        :return: all DBValidationContext
+        :rtype: List[DBValidationContext]
+        """
+        return self.bm.session.query(DBValidationContext).all()
+
+    def create_db_validation_context(self, valid, report_string, model_id):
+        """_summary_"""
+        report_id = str(uuid.uuid4())
+
+        db_validation_context = DBValidationContext(
+            valid=valid,
+            report_string=report_string,
+            report_id=report_id,
+            model_id=model_id,
+        )
+
+        self.bm.session.add(db_validation_context)
+
+        self.bm.session.flush()
+
+        return db_validation_context
+
+    def get_db_validation_context(self, id: int) -> DBValidationContext:
+        """Get database validation_context by id.
+
+        :param id: id of DBValidationContext
+        :type id: int
+        :return: DBValidationContext
+        :rtype: DBValidationContext
+        """
+        db_validation_context = (
+            self.bm.session.query(DBValidationContext)
+            .filter(DBValidationContext.id == id)
+            .one()
+        )
+        return db_validation_context
+
+    def delete_db_validation_context(self, id: int) -> None:
+        """Delete database validation_context.
+
+        :param id: id of deleted DBValidationContext
+        :type id: int
+        """
+
+        db_validation_context = self.get_db_validation_context(id)
+        self.logger.debug(f"Deleting validation_context: '{db_validation_context.id}'")
+        self.bm.session.delete(db_validation_context)

buildingmotif/database/tables.py

@@ -1,6 +1,15 @@
 from typing import Dict, List
 
-from sqlalchemy import Column, ForeignKey, Integer, String, Text, UniqueConstraint
+from sqlalchemy import (
+    TEXT,
+    Boolean,
+    Column,
+    ForeignKey,
+    Integer,
+    String,
+    Text,
+    UniqueConstraint,
+)
 from sqlalchemy.orm import Mapped, declarative_base, relationship
 
 # from sqlalchemy.dialects.postgresql import JSON
@@ -26,6 +35,10 @@ class DBModel(Base):
         cascade="all,delete",
     )
 
+    validation_contexts: Mapped[List["DBValidationContext"]] = relationship(
+        "DBValidationContext", back_populates="model", cascade="all,delete"
+    )
+
 
 class DBShapeCollection(Base):
     """A ShapeCollection is a collection of shapes, which are used to validate
@@ -113,3 +126,38 @@ class DBTemplate(Base):
             name="name_library_unique_constraint",
         ),
     )
+
+
+class ValidationContextShapeCollectionAssociation(Base):
+    """Many-to-many relationship between DBValidationContexts and DBShapeCollection."""
+
+    __tablename__ = "validation_context_shape_collection_association"
+
+    id: Mapped[int] = Column(Integer, primary_key=True)
+    shape_collection_id: Mapped[int] = Column(ForeignKey("shape_collection.id"))
+    validation_context_id: Mapped[int] = Column(ForeignKey("validation_context.id"))
+
+    __table_args__ = (
+        UniqueConstraint(
+            "shape_collection_id",
+            "validation_context_id",
+            name="validation_context_shape_collection_unique_constraint",
+        ),
+    )
+
+
+class DBValidationContext(Base):
+    __tablename__ = "validation_context"
+
+    id: Mapped[int] = Column(Integer, primary_key=True)
+    valid: Mapped[bool] = Column(Boolean, nullable=False)
+    report_string: Mapped[str] = Column(TEXT, nullable=False)
+    report_id: Mapped[str] = Column(String(), nullable=False)
+
+    shape_collections: Mapped[List[DBShapeCollection]] = relationship(
+        "DBShapeCollection", secondary="validation_context_shape_collection_association"
+    )
+    model_id: Mapped[int] = Column(Integer, ForeignKey("models.id"), nullable=False)
+    model: Mapped[DBModel] = relationship(
+        "DBModel", back_populates="validation_contexts"
+    )