trueppm-api 0.4.0__py3-none-any.whl

trueppm_api/apps/sync/serializers.py

@@ -0,0 +1,688 @@
+"""Serializers for the sync pull endpoint.
+
+Sync serializers always include server_version and is_deleted so mobile
+clients can track changes precisely. They are intentionally separate from
+the CRUD serializers — their contract is with the mobile offline store,
+not the REST API consumer.
+"""
+
+from __future__ import annotations
+
+import uuid
+from collections.abc import Iterator
+from typing import Any
+
+from rest_framework import serializers
+
+from trueppm_api.apps.access.models import ProgramMembership, ProjectMembership
+from trueppm_api.apps.integrations.models import TaskLink
+from trueppm_api.apps.projects.models import (
+    Calendar,
+    Dependency,
+    Label,
+    Program,
+    Project,
+    RetroActionItem,
+    Risk,
+    Sprint,
+    SprintRetro,
+    Task,
+    TaskRecurrenceRule,
+    TaskRelation,
+    TaskSuggestedAssignee,
+)
+from trueppm_api.apps.projects.serializers import CalendarExceptionSerializer
+from trueppm_api.apps.timetracking.models import TimeEntry
+
+
+def _is_uuid(value: object) -> bool:
+    """True if ``value`` parses as a UUID (the PK type of every synced row)."""
+    try:
+        uuid.UUID(str(value))
+    except (ValueError, TypeError, AttributeError):
+        return False
+    return True
+
+
+def _iter_upload_row_ids(attrs: dict[str, Any]) -> Iterator[object]:
+    """Yield every row id in an upload envelope: the ``id`` of each created/updated
+    row and each bare ``deleted`` id.
+
+    Rows are free-form ``DictField``s, so the id lives inside the row for
+    created/updated and is a bare string for deleted. Non-dict created/updated rows
+    carry no id and are skipped (they were surfaced as a ``None`` candidate before,
+    which the empty/absent-id filter dropped anyway — behavior is unchanged).
+    """
+    for bucket in ("created", "updated"):
+        for row in attrs.get(bucket, []) or []:
+            if isinstance(row, dict):
+                yield row.get("id")
+    yield from attrs.get("deleted", []) or []
+
+
+class SyncCalendarSerializer(serializers.ModelSerializer[Calendar]):
+    """Sync payload for Calendar. Exceptions ride the aggregate root (ADR-0193).
+
+    Exceptions are nested read-only rather than given their own sync collection:
+    they have no server_version of their own, and every exception write bumps the
+    parent Calendar.server_version, so a client that pulls the changed calendar
+    delta receives the full, current exception set inline. Critical-path math is
+    therefore holiday-aware offline.
+    """
+
+    exceptions = CalendarExceptionSerializer(many=True, read_only=True)
+
+    class Meta:
+        model = Calendar
+        fields = [
+            "id",
+            "server_version",
+            "name",
+            "working_days",
+            "hours_per_day",
+            "timezone",
+            "exceptions",
+        ]
+
+    def validate_timezone(self, value: str) -> str:
+        """Reject a non-IANA zone — same form as ``CalendarSerializer``.
+
+        Sync serves this serializer in the pull direction only today
+        (``upload.WRITABLE_COLLECTIONS`` names ``tasks`` alone), so this never runs;
+        it exists so that a push path added later inherits the write-time check every
+        other ``timezone`` field carries, rather than becoming the next unvalidated
+        write path.
+        """
+        from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+        stripped = (value or "").strip()
+        try:
+            ZoneInfo(stripped)
+        except (ZoneInfoNotFoundError, ValueError, OSError) as exc:
+            raise serializers.ValidationError("Unknown IANA timezone.") from exc
+        return stripped
+
+
+class SyncProjectSerializer(serializers.ModelSerializer[Project]):
+    """Sync payload for Project — minimal shape consumed by the WatermelonDB Project table.
+
+    ``program`` (ADR-0070) is included so mobile can render the program badge
+    on project rows offline. Program and ProgramMembership tables themselves
+    are not yet wired into mobile sync — the existing endpoint is project-scoped
+    and cannot reach user-scoped Program rows. Mobile-side Program sync is
+    tracked as a follow-up; for now mobile uses the REST endpoints online and
+    falls back to the cached project rows (with their ``program`` FK) offline.
+    """
+
+    class Meta:
+        model = Project
+        fields = [
+            "id",
+            "server_version",
+            "name",
+            "description",
+            "start_date",
+            "calendar",
+            "program",
+        ]
+
+
+class SyncTaskSerializer(serializers.ModelSerializer[Task]):
+    """Sync payload for Task — full CPM and baseline fields for offline scheduling previews."""
+
+    # Computed (ADR-0293): a non-subtask task with >=1 structural (non-subtask)
+    # child is a phase — a pure rollup whose status/estimate/assignee/percent are
+    # derived from its children. Read-only; annotated onto the sync tasks queryset
+    # in the pull view. ``default=False`` makes it safe if the annotation is absent
+    # (e.g. a bare instance in a test), matching TaskSerializer.is_phase.
+    is_phase = serializers.BooleanField(read_only=True, default=False)
+
+    # Task labels ride the task's own ``server_version`` as a flat id array rather
+    # than a synced join table (ADR-0400, mirroring SyncRiskSerializer.task_ids).
+    # Attaching/detaching a label bumps ``Task.server_version`` so this delta pulls.
+    # The pull view prefetches ``labels`` to avoid N+1.
+    label_ids = serializers.SerializerMethodField()
+
+    def get_label_ids(self, obj: Task) -> list[str]:
+        # Iterate the prefetched cache; values_list() bypasses it and fires an extra SELECT.
+        return [str(label.pk) for label in obj.labels.all()]
+
+    # Per-task custom-field values (#2143, ADR-0528) ride Task.server_version exactly like
+    # label_ids — the same flat {field_id: value} map the online Task payload carries, fed
+    # by the same prefetch. NB: offline *rendering* additionally needs the field definitions
+    # synced (deferred per ADR-0528); this map is forward-compatible until that lands.
+    custom_fields = serializers.SerializerMethodField()
+
+    def get_custom_fields(self, obj: Task) -> dict[str, Any]:
+        from trueppm_api.apps.projects.custom_field_values import build_custom_fields_map
+
+        return build_custom_fields_map(obj)
+
+    class Meta:
+        model = Task
+        fields = [
+            "id",
+            "server_version",
+            "short_id",
+            "project",
+            "name",
+            "wbs_path",
+            "status",
+            "duration",
+            "percent_complete",
+            "notes",
+            "planned_start",
+            "early_start",
+            "early_finish",
+            "scheduled_start",
+            "late_start",
+            "late_finish",
+            "total_float",
+            "free_float",
+            "is_critical",
+            "milestone_at_day_end",
+            "is_milestone",
+            "actual_start",
+            "actual_finish",
+            "optimistic_duration",
+            "most_likely_duration",
+            "pessimistic_duration",
+            "is_subtask",
+            "sprint",
+            "assignee",
+            "is_phase",
+            "label_ids",
+            "custom_fields",
+        ]
+
+
+class SyncDependencySerializer(serializers.ModelSerializer[Dependency]):
+    """Sync payload for Dependency links — includes server_version for delta tracking."""
+
+    class Meta:
+        model = Dependency
+        fields = ["id", "server_version", "predecessor", "successor", "dep_type", "lag"]
+
+
+class SyncTaskRelationSerializer(serializers.ModelSerializer[TaskRelation]):
+    """Sync payload for informational TaskRelation links (ADR-0455).
+
+    Pull-only, mirroring :class:`SyncDependencySerializer`: a relation is inert, so
+    the offline store needs only the endpoints, kind, and note plus the delta
+    bookkeeping (``server_version`` / ``is_deleted``) to reconcile. Not writable
+    from the client — it is deliberately absent from the sync-upload
+    WRITABLE_COLLECTIONS, exactly like Dependency.
+    """
+
+    class Meta:
+        model = TaskRelation
+        fields = [
+            "id",
+            "server_version",
+            "source",
+            "target",
+            "relation_type",
+            "note",
+            "is_deleted",
+        ]
+
+
+class SyncMembershipSerializer(serializers.ModelSerializer[ProjectMembership]):
+    """Sync payload for ProjectMembership — lets mobile clients enforce offline RBAC.
+
+    ``reinstated_at`` rides the delta (#3436) so an offline client can tell a
+    revived membership apart from one that never lapsed, the same discriminator
+    the online read serializer exposes — null iff this row has never been
+    revoked and re-added.
+    """
+
+    class Meta:
+        model = ProjectMembership
+        fields = ["id", "server_version", "project", "user", "role", "reinstated_at"]
+
+
+class SyncProgramSerializer(serializers.ModelSerializer[Program]):
+    """Sync payload for Program (ADR-0070 §Sync, #561).
+
+    Minimal shape the offline store needs to render the program list card and
+    header when the device has no signal: name/description/code/methodology plus
+    the display accents (health, color, target_date, lead). Rollup KPIs, sharing
+    overrides, and ceremony config are intentionally excluded — they are online-
+    only surfaces. Delivered by the user-scoped :class:`UserProgramSyncView`, the
+    endpoint ADR-0070 §Sync flagged as the 0.4 follow-up.
+    """
+
+    class Meta:
+        model = Program
+        fields = [
+            "id",
+            "server_version",
+            "name",
+            "description",
+            "code",
+            "methodology",
+            "health",
+            "color",
+            "target_date",
+            "lead",
+        ]
+
+
+class SyncProgramMembershipSerializer(serializers.ModelSerializer[ProgramMembership]):
+    """Sync payload for ProgramMembership — lets clients enforce offline program RBAC.
+
+    Mirrors :class:`SyncMembershipSerializer` (project membership) exactly: only
+    ``(program, user, role)`` plus the sync bookkeeping fields and
+    ``reinstated_at`` (#3436). The User table is not synced, so ``user`` is the
+    FK id — the client resolves display names from its own cached roster,
+    identical to the project-membership sync behaviour.
+    """
+
+    class Meta:
+        model = ProgramMembership
+        fields = ["id", "server_version", "program", "user", "role", "reinstated_at"]
+
+
+class SyncSprintSerializer(serializers.ModelSerializer[Sprint]):
+    """Sync payload for Sprint — enables offline sprint context for retros (ADR-0071)."""
+
+    class Meta:
+        model = Sprint
+        fields = [
+            "id",
+            "server_version",
+            "short_id",
+            "project",
+            "name",
+            "goal",
+            "start_date",
+            "finish_date",
+            "state",
+        ]
+
+
+class SyncSprintRetroSerializer(serializers.ModelSerializer[SprintRetro]):
+    """Sync payload for SprintRetro (ADR-0071).
+
+    Mobile receives the raw notes only when the caller's role meets the
+    retro's team_visibility threshold; the sync view is responsible for
+    filtering retros the caller cannot see. WatermelonDB stores what it
+    receives — the server-side visibility gate is the only check.
+    """
+
+    class Meta:
+        model = SprintRetro
+        fields = [
+            "id",
+            "server_version",
+            "sprint",
+            "notes",
+            "team_visibility",
+            "created_by",
+            "created_at",
+            "updated_at",
+        ]
+
+
+class SyncRetroActionItemSerializer(serializers.ModelSerializer[RetroActionItem]):
+    """Sync payload for RetroActionItem (ADR-0071)."""
+
+    class Meta:
+        model = RetroActionItem
+        fields = [
+            "id",
+            "server_version",
+            "retro",
+            "text",
+            "assignee",
+            "story_points",
+            "promoted_task_id",
+            "created_at",
+        ]
+
+
+class SyncTaskSuggestedAssigneeSerializer(serializers.ModelSerializer[TaskSuggestedAssignee]):
+    """Sync payload for TaskSuggestedAssignee (ADR-0071 §5)."""
+
+    class Meta:
+        model = TaskSuggestedAssignee
+        fields = [
+            "id",
+            "server_version",
+            "task",
+            "suggested_user",
+            "suggested_by",
+            "reason",
+            "source",
+            "state",
+            "created_at",
+            "accepted_at",
+            "declined_at",
+        ]
+
+
+class SyncTaskLinkSerializer(serializers.ModelSerializer[TaskLink]):
+    """Sync payload for TaskLink (ADR-0049 §3, #637) — links on a task.
+
+    Carries the cloud-file preview cache (#571, ADR-0163) so the preview card
+    renders offline on the mobile client straight from the sync delta.
+    """
+
+    class Meta:
+        model = TaskLink
+        fields = [
+            "id",
+            "server_version",
+            "task",
+            "url",
+            "provider",
+            "title",
+            "custom_title",
+            "labels",
+            "status",
+            "fetched_at",
+            "description",
+            "thumbnail_url",
+            "preview_type",
+            "display_order",
+        ]
+
+
+class SyncTaskRecurrenceRuleSerializer(serializers.ModelSerializer[TaskRecurrenceRule]):
+    """Sync payload for TaskRecurrenceRule (ADR-0090).
+
+    Omits the internal ``generated_through`` cursor — mobile clients recompute the
+    occurrence preview from the rule fields and never need the server-side cursor.
+    """
+
+    class Meta:
+        model = TaskRecurrenceRule
+        fields = [
+            "id",
+            "server_version",
+            "task",
+            "frequency",
+            "interval",
+            "weekdays",
+            "day_of_month",
+            "time_of_day",
+            "timezone",
+            "end_type",
+            "end_date",
+            "end_count",
+            "inherit_assignee",
+            "inherit_subtasks",
+            "inherit_attachments",
+            "inherit_morning_notification",
+        ]
+
+    def validate_timezone(self, value: str) -> str:
+        """Reject a non-IANA zone — same form as ``CalendarSerializer``.
+
+        Sync serves this serializer in the pull direction only today
+        (``upload.WRITABLE_COLLECTIONS`` names ``tasks`` alone), so this never runs;
+        it exists so that a push path added later inherits the write-time check every
+        other ``timezone`` field carries, rather than becoming the next unvalidated
+        write path.
+        """
+        from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
+
+        stripped = (value or "").strip()
+        try:
+            ZoneInfo(stripped)
+        except (ZoneInfoNotFoundError, ValueError, OSError) as exc:
+            raise serializers.ValidationError("Unknown IANA timezone.") from exc
+        return stripped
+
+
+class SyncRiskSerializer(serializers.ModelSerializer[Risk]):
+    """Sync serializer for the Risk model.
+
+    task_ids is serialized as a flat list of task UUIDs (string) rather than
+    a nested M2M sync table. Expected cardinality is 1–10 tasks per risk, so
+    a JSON column on the WatermelonDB Risk record is simpler and sufficient.
+    The queryset in ProjectSyncView prefetches tasks to avoid N+1.
+    """
+
+    task_ids = serializers.SerializerMethodField()
+
+    def get_task_ids(self, obj: Risk) -> list[str]:
+        # Iterate the prefetched cache; values_list() bypasses it and fires an extra SELECT.
+        return [str(t.pk) for t in obj.tasks.all()]
+
+    class Meta:
+        model = Risk
+        fields = [
+            "id",
+            "server_version",
+            "short_id",
+            "project",
+            "title",
+            "description",
+            "status",
+            "probability",
+            "impact",
+            "owner",
+            "task_ids",
+        ]
+
+
+class SyncLabelSerializer(serializers.ModelSerializer[Label]):
+    """Sync payload for the project-scoped label catalog (ADR-0400).
+
+    The ``Label`` catalog syncs as its own ``VersionedModel`` collection (colors +
+    curated vocabulary need a table). Assignment to a task is NOT synced here — it
+    rides ``Task.server_version`` via ``SyncTaskSerializer.label_ids``. Soft-deleted
+    rows ride the standard tombstone path (``is_deleted``/``deleted_version``).
+    """
+
+    class Meta:
+        model = Label
+        fields = [
+            "id",
+            "server_version",
+            "project",
+            "name",
+            "color",
+            "position",
+        ]
+
+
+class SyncTimeEntrySerializer(serializers.ModelSerializer[TimeEntry]):
+    """Sync payload for TimeEntry (ADR-0185 §6).
+
+    The per-project delta is filtered to ``user=request.user`` in ``ProjectSyncView``,
+    so a client only ever receives its **own** entries — the same non-surveillance
+    discipline as the REST surface (a Member never pulls a colleague's entries). Soft-
+    deleted rows ride the standard tombstone path. ``ActiveTimer`` is deliberately not
+    synced (transient/derived; recovered via ``GET /me/timer/``).
+    """
+
+    class Meta:
+        model = TimeEntry
+        fields = [
+            "id",
+            "server_version",
+            "task",
+            "user",
+            "minutes",
+            "entry_date",
+            "note",
+            "source",
+            "created_at",
+        ]
+
+
+# ---------------------------------------------------------------------------
+# Pull (GET) response envelope — documents the paginated delta shape (#1013).
+# ---------------------------------------------------------------------------
+
+
+class SyncPullResponseSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    """Response envelope for the paginated delta pull (#1013).
+
+    ``next_cursor``/``has_more`` are added for cursor pagination; the pre-existing
+    ``changes`` and ``timestamp`` fields are unchanged, so an older client that
+    ignores the cursor still gets a valid (first) page. The client loops while
+    ``has_more`` is true, sending the previous ``next_cursor`` back and keeping
+    ``since`` constant, then adopts ``timestamp`` as the next ``since``.
+    """
+
+    changes = serializers.DictField(
+        help_text="Per-collection WatermelonDB buckets (created/updated/deleted).",
+    )
+    timestamp = serializers.IntegerField(
+        help_text=(
+            "High-water mark to adopt as `since` once the delta is fully drained "
+            "(after the last page). Pinned when the session's first page is served "
+            "and identical on every page of that session. On the project pull, "
+            "whose cursor is the project's monotonic `sync_seq`, that means a row "
+            "written into an already-drained collection mid-drain still falls above "
+            "the adopted checkpoint and arrives on the next pull. The program pull "
+            "keys on the per-row `server_version` rather than a session sequence, "
+            "so pinning stops its checkpoint climbing mid-drain but does not yet "
+            "deliver that guarantee — see issue #2498."
+        ),
+    )
+    next_cursor = serializers.CharField(
+        allow_null=True,
+        help_text=(
+            "Opaque continuation token. Pass it as the `cursor` query param on the "
+            "next request; `null` when the delta is exhausted."
+        ),
+    )
+    has_more = serializers.BooleanField(
+        help_text=(
+            "DEPRECATED — removed in 0.5. True while more pages remain for this "
+            "`since` session. Exactly equivalent to `next_cursor is not null`; loop "
+            "on that instead. Announced here rather than removed in 0.4 (#2842) "
+            "because a client following the published drain loop would read "
+            "`undefined`, treat it as false, and silently stop after page one — "
+            "missing data presented as a complete sync."
+        ),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Upload (push) serializer — mobile offline → server (ADR-0082, issue #667)
+#
+# Validates only the batch envelope. Per-row task validation reuses the REST
+# TaskSerializer (in sync.upload) so mobile writes inherit identical field
+# rules and business logic — see ADR-0082 §E.
+# ---------------------------------------------------------------------------
+
+
+class SyncUploadCollectionSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    """WatermelonDB per-collection change buckets — created / updated / deleted.
+
+    Mirrors the shape WatermelonDB's ``synchronize()`` pushes for one collection:
+    ``created`` and ``updated`` are lists of full row objects, ``deleted`` is a
+    list of record ids (UUID strings). Row objects are deliberately free-form
+    (``DictField``) rather than a typed row serializer: per-field task validation
+    is delegated to ``TaskSerializer`` inside ``sync.upload`` so mobile writes
+    inherit identical field rules and business logic (ADR-0082 §E). All three
+    buckets are optional; an absent bucket means "no changes of that kind".
+    """
+
+    created = serializers.ListField(child=serializers.DictField(), required=False)
+    updated = serializers.ListField(child=serializers.DictField(), required=False)
+    deleted = serializers.ListField(child=serializers.CharField(), required=False)
+
+    def validate(self, attrs: dict[str, Any]) -> dict[str, Any]:
+        # #1730: every row id here reaches a ``Task.objects.filter(pk__in=...)``
+        # in ``sync.upload``. A malformed (non-UUID) id would raise a django-core
+        # ValidationError/ValueError at query build that DRF does not catch → 500.
+        # Validate the ids up front so a bad one is a clean 400. Empty/absent ids are
+        # left to ``sync.upload``'s existing "each row requires an 'id'" guard so its
+        # message is unchanged.
+        bad = [
+            str(row_id) for row_id in _iter_upload_row_ids(attrs) if row_id and not _is_uuid(row_id)
+        ]
+        if bad:
+            raise serializers.ValidationError(
+                {"id": f"Row ids must be valid UUIDs; got: {', '.join(bad[:5])}."}
+            )
+        return attrs
+
+
+class SyncUploadChangesSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    """The ``changes`` map of an upload envelope, keyed by collection name.
+
+    v1 exposes only the writable ``tasks`` collection (ADR-0082 §B); every other
+    collection is pull-only. Unsupported collection keys are **not** rejected
+    here — ``apply_task_changes`` is the single authority for the writable-
+    collection whitelist and rejects them with an explicit 400 (rather than
+    silently dropping them). This serializer therefore documents the writable
+    shape in the OpenAPI schema without masking that guard; the view feeds the
+    raw ``changes`` map to ``apply_task_changes`` so behavior stays identical.
+    """
+
+    tasks = SyncUploadCollectionSerializer(required=False)
+
+
+class SyncUploadRequestSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    """Validate the envelope of a mobile upload batch (ADR-0082 §A).
+
+    ``changes`` is a typed nested map (per-collection created/updated/deleted
+    lists) so the WatermelonDB upload shape is explicit in the OpenAPI schema and
+    the generated web types, instead of the opaque object it was before (#786).
+    Per-collection row validation still happens in ``sync.upload`` so an
+    unsupported collection can be rejected with an explicit 400 rather than
+    silently dropped. ``last_pulled_at`` is the client's last-pull high-water mark
+    and is the default per-row base version for the field-level conflict guard
+    (#1718): a stale edit that overlaps a concurrent writer is reported in the
+    response ``conflicts`` collection instead of silently clobbering. Omit it (and
+    any per-row ``base_version``) to keep plain last-writer-wins.
+    """
+
+    client_batch_id = serializers.UUIDField()
+    last_pulled_at = serializers.IntegerField(required=False, min_value=0)
+    changes = SyncUploadChangesSerializer()
+
+
+class SyncUploadAppliedTasksSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    """The ``applied.tasks`` bucket of an upload response — rows actually written.
+
+    Mirrors :class:`SyncUploadCollectionSerializer`'s shape (created/updated as
+    full row objects, deleted as row dicts too — the view echoes back the applied
+    content rather than just ids). Row objects are deliberately free-form
+    (``DictField``), same rationale as the request-side collection serializer:
+    the row shape is whatever ``TaskSerializer`` produced inside ``sync.upload``,
+    not re-declared here (#3652/#3681).
+    """
+
+    created = serializers.ListField(child=serializers.DictField(), read_only=True)
+    updated = serializers.ListField(child=serializers.DictField(), read_only=True)
+    deleted = serializers.ListField(child=serializers.DictField(), read_only=True)
+
+
+class SyncUploadAppliedSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    """The ``applied`` envelope of an upload response, keyed by collection name."""
+
+    tasks = SyncUploadAppliedTasksSerializer(read_only=True)
+
+
+class SyncUploadConflictsSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    """The ``conflicts`` envelope of an upload response, keyed by collection name.
+
+    Each entry is the REST-parity 409 body (``conflict_fields`` / ``server_value``
+    / ``client_value`` / ``server_version``) plus the row ``id`` — free-form here
+    for the same reason as the applied-row buckets above.
+    """
+
+    tasks = serializers.ListField(child=serializers.DictField(), read_only=True)
+
+
+class SyncUploadResponseSerializer(serializers.Serializer):  # type: ignore[type-arg]
+    """``200`` body of ``POST /api/v1/projects/{pk}/sync/`` (ADR-0082 §D, #3681).
+
+    ``client_batch_id`` echoes the request so a client can correlate a fast-path
+    replay with the original submission. ``timestamp`` is the batch's high-water
+    ``sync_seq`` cursor (see :class:`BatchApplyResult.max_version`) — adopt it as
+    the next pull's ``since`` once conflicts (if any) are resolved.
+    """
+
+    client_batch_id = serializers.CharField(read_only=True)
+    applied = SyncUploadAppliedSerializer(read_only=True)
+    conflicts = SyncUploadConflictsSerializer(read_only=True)
+    timestamp = serializers.IntegerField(read_only=True)