Revert "Renaming"

This reverts commit 8ace729.

Author: jeffmaki

api/src/workspaces/models.py

@@ -1,157 +1,100 @@
-import json
-from datetime import datetime
-from typing import Any, Optional
-from uuid import UUID
+from enum import Enum
 
-import requests
-from geoalchemy2 import WKBElement
-from jsonschema import ValidationError, validate
-from pydantic import BaseModel, ConfigDict, Field, Json, field_validator
-from typing_extensions import Annotated
+from geoalchemy2 import Geometry
+from sqlalchemy import (
+    JSON,
+    UUID,
+    Column,
+    DateTime,
+    ForeignKey,
+    Integer,
+    SmallInteger,
+    Unicode,
+)
+from sqlalchemy.orm import Mapped, relationship
+from sqlalchemy.sql import func
 
-from api.core.config import Settings
-from api.src.workspaces.schemas import ExternalAppsDefinitionType, QuestDefinitionType
+from api.core.database import Base
 
-class WorkspaceLongQuestBase(BaseModel):
 
-    workspace_id: int
+class ExternalAppsDefinitionType(Enum):
+    NONE = 0
+    PUBLIC = 1
+    PROJECT_GROUP = 2
 
-    definition: Optional[str]
-    type: QuestDefinitionType
-    url: Optional[str]
 
-    modifiedAt: datetime
-    modifiedBy: UUID
-    modifiedByName: str
+class Workspace(Base):
+    """Workspaces"""
 
-    model_config = ConfigDict(from_attributes=True)
+    __tablename__ = "workspaces"
 
-    def validate_definition(self, data, value):
-        if QuestDefinitionType[data["type"]] == QuestDefinitionType.NONE:
-            if not value:
-                return None
-            raise ValidationError("'definition' field not allowed.")
+    id = Column(Integer, primary_key=True)
+    type = Column(Unicode, nullable=False)
 
-        if QuestDefinitionType[data["type"]] != QuestDefinitionType.JSON:
-            return value
+    title = Column(Unicode, nullable=False)
+    description = Column(Unicode)
 
-        if not value:
-            raise ValidationError("This field is required.")
-        if data["url"]:
-            raise ValidationError("'url' field not allowed.")
+    tdeiProjectGroupId = Column(UUID(as_uuid=True), nullable=False)
+    tdeiRecordId = Column(UUID(as_uuid=True))
+    tdeiServiceId = Column(UUID(as_uuid=True))
 
-        try:
-            parsed = json.loads(value)
-            if not parsed or not isinstance(parsed, dict):
-                raise ValidationError("must be a JSON object.")
-            validate_json_against_schema(parsed, Settings.WS_LONGFORM_SCHEMA_URL)
-        except json.JSONDecodeError as e:
-            return ValidationError(f"{e}")
-        except ValidationError as e:
-            raise ValidationError(f"{e}")
+    tdeiMetadata = Column(JSON)
 
-        return value
+    createdAt = Column(DateTime, nullable=False, default=func.now())
+    createdBy = Column(UUID(as_uuid=True), nullable=False)
+    createdByName = Column(Unicode)
 
-    def validate_url(self, data, value):
-        if QuestDefinitionType[data["type"]] == QuestDefinitionType.NONE:
-            if not value:
-                return None
-            raise ValidationError("'url' field not allowed.")
+    geometry = Column(Geometry("MULTIPOLYGON", srid=4326))
 
-        if QuestDefinitionType[data["type"]] != QuestDefinitionType.URL:
-            return value
+    externalAppAccess = Column(
+        SmallInteger, nullable=False, default=ExternalAppsDefinitionType.NONE.value
+    )
 
-        if not value:
-            raise ValidationError("This field is required.")
-        if data["definition"]:
-            raise ValidationError("'definition' field not allowed.")
+    kartaViewToken = Column(Unicode)
 
-        return value
+    longFormQuestDef: Mapped[list["WorkspaceLongQuest"]] = relationship(
+        "WorkspaceLongQuest", uselist=False, lazy="joined", cascade="all, delete"
+    )
 
-class WorkspaceLongQuestUpdate(BaseModel):
-    definition: Optional[str]
-    url: Optional[str]
+    imageryListDef: Mapped[list["WorkspaceImagery"]] = relationship(
+        "WorkspaceImagery", uselist=False, lazy="joined", cascade="all, delete"
+    )
 
-class WorkspaceImageryBase(BaseModel):
 
-    workspace_id: int
+class QuestDefinitionType(Enum):
+    NONE = 0
+    JSON = 1
+    URL = 2
 
-    # Note the below column is of the JSON *database* type vs string type, so we're not
-    # using pydantic's JSON mapping, hence this is not defined as Optional[Json[Any]]
-    definition: Optional[list[Any]]
 
-    modifiedAt: datetime
-    modifiedBy: UUID
-    modifiedByName: str
+class WorkspaceLongQuest(Base):
+    """Stores mobile app quest definitions for a workspace"""
 
-    model_config = ConfigDict(from_attributes=True)
+    __tablename__ = "workspaces_long_quests"
 
-class WorkspaceImageryUpdate(BaseModel):
-    definition: Optional[str]
+    workspace_id = Column(Integer, ForeignKey(Workspace.id), primary_key=True)
 
-class WorkspaceBase(BaseModel):
+    definition = Column(Unicode, nullable=True, default=None)
+    type = Column(Integer, nullable=False, default=QuestDefinitionType.NONE.value)
+    url = Column(Unicode, nullable=True, default=None)
 
-    id: int
-    type: str = Field(...)
+    modifiedAt = Column(
+        DateTime, nullable=False, default=func.now(), onupdate=func.now()
+    )
+    modifiedBy = Column(UUID(as_uuid=True), nullable=False)
+    modifiedByName = Column(Unicode, nullable=False)
 
-    title: str = Field(...)
-    description: Optional[str]
 
-    tdeiProjectGroupId: UUID
-    tdeiRecordId: Optional[UUID]
-    tdeiServiceId: Optional[UUID]
+class WorkspaceImagery(Base):
+    """Stores imagery list for a workspace"""
 
-    tdeiMetadata: Optional[Json[Any]]
+    __tablename__ = "workspaces_imagery"
 
-    createdAt: datetime
-    createdBy: UUID
-    createdByName: str
+    workspace_id = Column(Integer, ForeignKey(Workspace.id), primary_key=True)
+    definition = Column(JSON, nullable=True, default=None)
 
-    geometry: Optional[Annotated[str, WKBElement]]
-
-    externalAppAccess: ExternalAppsDefinitionType
-
-    kartaViewToken: Optional[str]
-
-    longFormQuestDef: Optional[WorkspaceLongQuestBase]
-
-    imageryListDef: Optional[WorkspaceImageryBase]
-
-    model_config = ConfigDict(from_attributes=True)
-
-    # there are some legacy records with '', which is not valid JSON, so map those to None
-    @field_validator("*", mode="before")
-    @classmethod
-    def empty_str_to_none(cls, v):
-        if v == "":
-            return None
-        return v
-
-
-class WorkspaceCreate(WorkspaceBase):
-    pass
-
-class WorkspaceUpdate(BaseModel):
-    title: Optional[str] = None 
-    description: Optional[str] = None 
-    externalAppAccess: Optional[ExternalAppsDefinitionType] = None 
-    longFormQuestDef: Optional[WorkspaceLongQuestBase] = None 
-    imageryListDef: Optional[WorkspaceImageryBase] = None 
-
-class WorkspaceResponse(WorkspaceBase):
-    pass
-
-
-def validate_json_against_schema(json, schema_url) -> bool:
-    """
-    Validate a JSON string against a JSON schema from a URL.
-    Returns True if valid, raises ValidationError if not.
-    """
-    # Fetch the schema
-    response = requests.get(schema_url)
-    response.raise_for_status()
-    schema = response.json()
-
-    # Validate
-    validate(instance=json, schema=schema)
-    return True
+    modifiedAt = Column(
+        DateTime, nullable=False, default=func.now(), onupdate=func.now()
+    )
+    modifiedBy = Column(UUID(as_uuid=True), nullable=False)
+    modifiedByName = Column(Unicode, nullable=False)

api/src/workspaces/repository.py

@@ -1,4 +1,3 @@
-from typing import Any
 from sqlalchemy import delete, select, update
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.asyncio import AsyncSession
@@ -58,7 +57,7 @@ async def update(
         self,
         projectGroupIds: list[str],
         workspace_id: int,
-        workspace_data: Any,
+        workspace_data: WorkspaceUpdate,
     ) -> Workspace:
         update_data = workspace_data.model_dump(exclude_unset=True)
         if not update_data:

api/src/workspaces/routes.py

@@ -1,13 +1,16 @@
-from typing import Any
 from fastapi import APIRouter, Depends, HTTPException, status
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from api.core.database import get_session
 from api.core.logging import get_logger
 from api.core.security import UserInfo, validate_token
-from api.src.workspaces.models import WorkspaceCreate, WorkspaceLongQuestBase, WorkspaceLongQuestUpdate, WorkspaceResponse, WorkspaceUpdate
 from api.src.workspaces.repository import WorkspaceRepository
-
+from api.src.workspaces.schemas import (
+    WorkspaceCreate,
+    WorkspaceLongQuestBase,
+    WorkspaceResponse,
+    WorkspaceUpdate,
+)
 from api.src.workspaces.service import WorkspaceService
 
 # Set up logger for this module
@@ -76,11 +79,8 @@ async def update_workspace(
     current_user: UserInfo = Depends(validate_token),
 ) -> WorkspaceResponse:
     try:
-        newWorkspaceRecord = await service.get_workspace(current_user.projectGroups, workspace_id)
-        newWorkspaceRecord.model_copy(update=workspace_data.model_dump(exclude_unset=True))
-
         workspace = await service.update_workspace(
-            current_user.projectGroups, workspace_id, newWorkspaceRecord
+            current_user.projectGroups, workspace_id, workspace_data
         )
         return workspace
     except Exception as e:
@@ -142,7 +142,7 @@ async def get_long_quest_settings(
 @router.patch("/{workspace_id}/quests/long/settings", response_model=WorkspaceLongQuestBase)
 async def update_long_quest_settings(
     workspace_id: int,
-    longform_quest_data: WorkspaceLongQuestUpdate,
+    workspace_data: WorkspaceUpdate,
     service: WorkspaceService = Depends(get_workspace_service),
     current_user: UserInfo = Depends(validate_token),
 ) -> WorkspaceLongQuestBase | None:
@@ -151,10 +151,7 @@ async def update_long_quest_settings(
             current_user.projectGroups, workspace_id
         ) # type: ignore
 
-        update_data = longform_quest_data.model_dump(exclude_unset=True)
-        
-        if(workspace.longFormQuestDef is not None):
-            workspace.longFormQuestDef.model_copy(update=update_data)
+#        workspace.longFormQuestDef = longform_quest_data
 
         updatedWorkspace = await service.update_workspace(
             current_user.projectGroups, workspace_id, workspace