A2-2: Рендерер форм (React) для internal model (Issue #11)

- Для документов введена возможность заполнения. При заполнении на основе связанной с документом XSD схемы строятся формы
- Текущее заполнение формы сохраняется в самую последнюю версию документа, если документ ранее не сохранялся, создается новая версия.
- Есть возможность сохранения в новую версию, предыдущая при этом остается "в архиве". Работа с версиями будет реализована позднее.
- При формировании формы и наличии текущей сохраненной версии документа, форма заполняется данными из сохраненной версии.
- Реализованы повторяемые узлы-массивы, с возможностью добавления, удаления и изменения порядка элементов.
- Реализована базовая валидация на клиенте (контроль количества элементов для массивов, обязательных полей, заполненности полей).
  Поля и группы полей с ошибками подсвечиваются, информация об ошибках выводится.
  При сохранении формы с ошибками сохранение происходит, но выводится предупреждение с указанием количества ошибок.

Author: knoff

app/api/routes/document_versions.py

@@ -10,6 +10,9 @@
 class SaveDraftIn(BaseModel):
     payload: dict
 
+class VersionIn(BaseModel):
+     payload: dict
+
 class VersionOut(BaseModel):
     id: int
     document_id: int
@@ -42,6 +45,56 @@ def list_versions(document_id: int, db: Session = Depends(get_db)):
     )
     return [VersionOut(id=r.id, document_id=r.document_id, payload=r.payload, created_at=r.created_at) for r in rows]
 
+# get one version by id (primary key)
+@router.get("/{document_id}/version/{version_id}", response_model=VersionOut)
+@router.get("/{document_id}/versions/{version_id}", response_model=VersionOut)
+def get_version(document_id: int, version_id: int, db: Session = Depends(get_db)):
+    doc = db.get(DocumentRow, document_id)
+    if not doc:
+        raise HTTPException(404, "Документ не найден")
+    v = db.get(DocumentVersionRow, version_id)
+    if not v or v.document_id != document_id:
+        raise HTTPException(404, "Версия не найдена")
+    return VersionOut(id=v.id, document_id=v.document_id, payload=v.payload, created_at=v.created_at)
+
+# latest version helper
+@router.get("/{document_id}/versions/latest", response_model=VersionOut)
+def latest_version(document_id: int, db: Session = Depends(get_db)):
+    doc = db.get(DocumentRow, document_id)
+    if not doc:
+        raise HTTPException(404, "Документ не найден")
+    v = (
+        db.query(DocumentVersionRow)
+          .filter(DocumentVersionRow.document_id == document_id)
+          .order_by(DocumentVersionRow.id.desc())
+          .first()
+    )
+    if not v:
+        raise HTTPException(404, "Версии отсутствуют")
+    return VersionOut(id=v.id, document_id=v.document_id, payload=v.payload, created_at=v.created_at)
+
+@router.put("/{document_id}/versions/latest", response_model=VersionOut)
+def upsert_latest_version(document_id: int, body: VersionIn, db: Session = Depends(get_db)):
+    """
+    Create first version if none exists; otherwise update payload of the latest version.
+    """
+    doc = db.get(DocumentRow, document_id)
+    if not doc:
+        raise HTTPException(404, "Документ не найден")
+    v = (db.query(DocumentVersionRow)
+           .filter(DocumentVersionRow.document_id == document_id)
+           .order_by(DocumentVersionRow.id.desc())
+           .first())
+    if not v:
+        v = DocumentVersionRow(document_id=document_id, payload=body.payload, created_at=datetime.utcnow())
+        db.add(v)
+        db.commit(); db.refresh(v)
+        return VersionOut(id=v.id, document_id=v.document_id, payload=v.payload, created_at=v.created_at)
+    # overwrite latest
+    v.payload = body.payload
+    db.commit(); db.refresh(v)
+    return VersionOut(id=v.id, document_id=v.document_id, payload=v.payload, created_at=v.created_at)
+
 class PatchStatusIn(BaseModel):
     status: str
 

app/api/routes/documents_crud.py

@@ -4,7 +4,7 @@
 from pydantic import BaseModel
 from sqlalchemy.orm import Session, joinedload
 from app.db import get_db
-from app.models_sqlalchemy import DocumentRow, ObjectRow, Schema
+from app.models_sqlalchemy import DocumentRow, ObjectRow, Schema, DocumentVersionRow
 
 router = APIRouter(prefix="/documents", tags=["documents"])
 
@@ -22,6 +22,10 @@ class DocumentOut(BaseModel):
     created_at: datetime | None = None
     updated_at: datetime | None = None
 
+class DocumentWithLatestOut(DocumentOut):
+    latest_version_id: int | None = None
+    payload: dict | None = None
+
 def _pack(doc: DocumentRow, obj: ObjectRow | None, sch: Schema | None) -> DocumentOut:
     return DocumentOut(
         id=doc.id, doc_uid=doc.doc_uid, status=doc.status,
@@ -62,13 +66,21 @@ def create_document(body: CreateDocumentIn, db: Session = Depends(get_db)):
     db.add(d); db.commit(); db.refresh(d)
     return _pack(d, obj, sch)
 
-@router.get("/{doc_id}", response_model=DocumentOut)
+@router.get("/{doc_id}", response_model=DocumentWithLatestOut)
 def get_document(doc_id: int, db: Session = Depends(get_db)):
     d = db.get(DocumentRow, doc_id)
     if not d: raise HTTPException(404, "not found")
     obj = db.get(ObjectRow, d.object_id) if d.object_id else None
     sch = db.get(Schema, int(d.schema_id)) if d.schema_id else None
-    return _pack(d, obj, sch)
+    # latest version (id + payload)
+    v = (
+        db.query(DocumentVersionRow)
+          .filter(DocumentVersionRow.document_id == d.id)
+          .order_by(DocumentVersionRow.id.desc())
+          .first()
+    )
+    base = _pack(d, obj, sch).dict()
+    return DocumentWithLatestOut(**base, latest_version_id=(v.id if v else None), payload=(v.payload if v else None))
 
 class PatchDocumentIn(BaseModel):
     status: str | None = None

app/main.py

@@ -6,7 +6,7 @@
 from app.api.routes.health import router as health_router
 from app.api.routes.schemas import router as schemas_router
 from app.api.routes.schema_types import router as schema_types_router
-from app.api.routes.documents import router as documents_router
+# from app.api.routes.documents import router as documents_router
 from app.api.routes.objects import router as objects_router
 from app.api.routes.documents_crud import router as documents_crud_router
 from app.api.routes.document_versions import router as doc_versions_router
@@ -19,7 +19,9 @@
 app.include_router(health_router,       tags=["system"],       prefix="/api")
 app.include_router(schemas_router,      tags=["schemas"],      prefix="/api")
 app.include_router(schema_types_router, tags=["schema-types"], prefix="/api")
-app.include_router(documents_router,    tags=["documents"],    prefix="/api")
+# NOTE: legacy in-memory documents router disabled to avoid path conflicts
+# from app.api.routes.documents import router as documents_router
+# app.include_router(documents_router,    tags=["documents"],    prefix="/api")
 app.include_router(objects_router,      tags=["objects"],      prefix="/api")
 app.include_router(documents_crud_router, tags=["documents"],  prefix="/api")
 app.include_router(doc_versions_router, tags=["documents"],    prefix="/api")

app/services/xsd_internal.py

@@ -5,6 +5,8 @@
 
 XS = "http://www.w3.org/2001/XMLSchema"
 NS = {"xs": XS}
+_TYPES_REGISTRY: Dict[str, Dict[str, Any]] = {}
+_ROOT_NODE: Optional[etree._Element] = None  # to resolve global xs:group by @ref
 
 # ---- Internal model data-classes (serialized to JSON) -----------------------
 
@@ -29,21 +31,29 @@ class FieldDoc:
 @dataclass
 class FieldModel:
     # common
-    kind: str                 # "element" | "attribute"
+    kind: str                 # "element" | "attribute" | "choice"
     name: str
     dtype: str                # xs:<builtin> | QName of named type | "object" for complex
+    refType: Optional[str] = None   # when element points to a named type (simple/complex)
     minOccurs: int = 1
     maxOccurs: Optional[int] = 1  # None => unbounded
     required: Optional[bool] = None  # for attributes (use="required")
     documentation: Optional[FieldDoc] = None
     facets: Optional[Facets] = None
     children: Optional[List["FieldModel"]] = None  # for complex/object
     attributes: Optional[List["FieldModel"]] = None
+    # для choice: варианты лежат в children, каждый вариант — это полноценный FieldModel (обычно element)
 
     def to_dict(self) -> Dict[str, Any]:
         d = asdict(self)
-        # compact None values
-        return {k: v for k, v in d.items() if v is not None}
+        # Keep maxOccurs even if None (unbounded); prune other Nones
+        out: Dict[str, Any] = {}
+        for k, v in d.items():
+            if k == "maxOccurs":
+                out[k] = v  # may be None → JSON null (means unbounded)
+            elif v is not None:
+                out[k] = v
+        return out
 
 @dataclass
 class SchemaModel:
@@ -142,13 +152,25 @@ def _parse_complex_type(ct: etree._Element) -> Dict[str, Any]:
     # Handle sequence/choice/all and attributes
     documentation = _first_doc(ct)
     children: List[FieldModel] = []
-    # Content model (sequence | choice | all)
-    for tag in ("sequence", "choice", "all"):
-        group = ct.find(f"./xs:{tag}", namespaces=NS)
-        if group is not None:
-            for el in group.findall("./xs:element", namespaces=NS):
-                children.append(_parse_element(el))
-            break
+    # Content model (sequence | choice | all | group), supports complexContent/extension
+    group = None
+    # unwrap complexContent/extension if present
+    cc = ct.find("./xs:complexContent", namespaces=NS)
+    if cc is not None:
+        ext = cc.find("./xs:extension", namespaces=NS)
+        if ext is not None:
+            # descend into its model group
+            for tag in ("sequence", "choice", "all", "group"):
+                group = ext.find(f"./xs:{tag}", namespaces=NS)
+                if group is not None:
+                    break
+    if group is None:
+        for tag in ("sequence", "choice", "all", "group"):
+            group = ct.find(f"./xs:{tag}", namespaces=NS)
+            if group is not None:
+                break
+    if group is not None:
+        children.extend(_parse_model_group(group))
     # attributes (xs:attribute)
     attrs: List[FieldModel] = []
     for a in ct.findall("./xs:attribute", namespaces=NS):
@@ -162,6 +184,67 @@ def _parse_complex_type(ct: etree._Element) -> Dict[str, Any]:
         result["documentation"] = asdict(documentation)
     return result
 
+def _parse_model_group(group: etree._Element) -> List[FieldModel]:
+    """
+    Recursively parse xs:sequence|xs:choice|xs:all|xs:group, preserving nested choices.
+    For xs:group with @ref, resolve the global group and parse its content.
+    """
+    out: List[FieldModel] = []
+    if not isinstance(group.tag, str):
+        return []
+    tag_local = group.tag.split("}")[-1]
+
+    # Resolve xs:group @ref → inline referenced global group
+    if tag_local == "group":
+        ref = group.get("ref")
+        if ref and _ROOT_NODE is not None:
+            gmin, gmax = _occurs(group)  # multiplicity on the referencing <xs:group>
+            # strip prefix if any (ns:name -> name)
+            ref_name = ref.split(":")[-1]
+            gdef = _ROOT_NODE.find(f".//xs:group[@name='{ref_name}']", namespaces=NS)
+            if gdef is not None:
+                # group definition contains its own sequence/choice/all
+                for t in ("sequence","choice","all"):
+                    inner = gdef.find(f"./xs:{t}", namespaces=NS)
+                    if inner is not None:
+                        inner_fms = _parse_model_group(inner)
+                        # If the referenced group is a single CHOICE — apply occurrences from the referencing node
+                        if len(inner_fms) == 1 and inner_fms[0].kind == "choice":
+                            inner_fms[0].minOccurs = gmin
+                            inner_fms[0].maxOccurs = gmax  # None → unbounded; preserved by to_dict()
+                        out.extend(inner_fms)
+                        return out
+        # fallthrough: unknown group → ignore silently (safe default)
+        return out
+
+    if tag_local == "choice":
+        # preserve multiplicity of the CHOICE group itself
+        mi, ma = _occurs(group)   # ma == None for unbounded
+        alts = [ _parse_element(el) for el in group.findall("./xs:element", namespaces=NS) ]
+        out.append(FieldModel(
+            kind="choice",
+            name="__choice__",
+            dtype="object",
+            minOccurs=mi,
+            maxOccurs=ma,          # <-- IMPORTANT: don't normalize 1 → keep None for unbounded
+            documentation=_first_doc(group),
+            children=alts,
+        ))
+        return out
+
+    # sequence / all: iterate *children nodes*, may include comments/PIs -> guard
+    for node in list(group):
+        # lxml: for comments/PI node.tag is a cython function (etree.Comment / etree.PI)
+        if not isinstance(node.tag, str):
+            continue
+        ntag = node.tag.split("}")[-1]
+        if ntag == "element":
+            out.append(_parse_element(node))
+        elif ntag in ("sequence","choice","all","group"):
+            out.extend(_parse_model_group(node))
+        # other particles (any) are ignored for now
+    return out
+
 def _occurs(node: etree._Element) -> Tuple[int, Optional[int]]:
     mi = node.get("minOccurs")
     ma = node.get("maxOccurs")
@@ -235,6 +318,32 @@ def _parse_element(el: etree._Element) -> FieldModel:
         return fm
 
     # plain reference to named type (simple or complex)
+    if dtype and dtype in _TYPES_REGISTRY:
+        t = _TYPES_REGISTRY[dtype]
+        if t.get("kind") == "simpleType":
+            base = t.get("base") or "xs:string"
+            return FieldModel(
+                kind="element",
+                name=name,
+                dtype=base,
+                refType=dtype,
+                minOccurs=minOccurs,
+                maxOccurs=maxOccurs if maxOccurs != 1 else 1,
+                documentation=documentation,
+                facets=(Facets(**t["facets"]) if t.get("facets") else None),
+            )
+        else:
+            # complexType: keep a shallow node; renderer will resolve from types[dtype]
+            return FieldModel(
+                kind="element",
+                name=name,
+                dtype="object",
+                refType=dtype,
+                minOccurs=minOccurs,
+                maxOccurs=maxOccurs if maxOccurs != 1 else 1,
+                documentation=documentation,
+            )
+    # fallback — как было
     return FieldModel(
         kind="element",
         name=name,
@@ -251,6 +360,10 @@ def build_internal_model(content: bytes) -> Dict[str, Any]:
 
     # registry of named types
     types = _resolve_named_types(root)
+    global _TYPES_REGISTRY
+    _TYPES_REGISTRY = types
+    global _ROOT_NODE
+    _ROOT_NODE = root
 
     # root elements (top-level xs:element)
     roots: List[FieldModel] = []