559 lines
27 KiB
Python
559 lines
27 KiB
Python
# Copyright (c) 2026 Patrick Motsch
|
|
# All rights reserved.
|
|
"""Redmine feature data models.
|
|
|
|
Two layers:
|
|
|
|
1. **Persisted** (``PowerOnModel``, auto-DDL into ``poweron_redmine``):
|
|
- ``RedmineInstanceConfig``: per-feature-instance connection + sync state.
|
|
- ``RedmineTicketMirror``: local mirror of a Redmine issue.
|
|
- ``RedmineRelationMirror``: local mirror of an issue relation.
|
|
|
|
2. **Transport** (plain Pydantic): ``Redmine*Dto`` returned over the
|
|
REST API and shared with the AI tools. The frontend (``RedmineStatsPage``)
|
|
maps the raw ``RedmineStatsDto`` buckets onto ``ReportSection`` for
|
|
``FormGeneratorReport``.
|
|
|
|
Scale: the mirror tables let us aggregate stats and render the ticket tree
|
|
for projects with 20k+ tickets without round-tripping the Redmine REST API
|
|
on every request.
|
|
"""
|
|
|
|
import uuid
|
|
from typing import Any, Dict, List, Optional
|
|
|
|
from pydantic import BaseModel, Field, model_validator
|
|
|
|
from modules.datamodels.datamodelBase import PowerOnModel
|
|
from modules.shared.i18nRegistry import i18nModel
|
|
|
|
|
|
def _coerceNoneToDefaults(cls, values):
|
|
"""Replace None values with each field's declared default.
|
|
|
|
Reason: Postgres rows written before we added a column return NULL for
|
|
that column, which Pydantic v2 rejects for non-Optional fields even if
|
|
a default is declared. We only apply the default when the incoming
|
|
value is explicitly None AND the field has a default (not a
|
|
default_factory that would generate a new value).
|
|
"""
|
|
if not isinstance(values, dict):
|
|
return values
|
|
for name, field in cls.model_fields.items():
|
|
if name in values and values[name] is None and field.default is not None:
|
|
values[name] = field.default
|
|
return values
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Persisted: per feature-instance Redmine connection config + sync state
|
|
# ---------------------------------------------------------------------------
|
|
|
|
@i18nModel("Redmine-Verbindung")
|
|
class RedmineInstanceConfig(PowerOnModel):
|
|
"""Per feature-instance Redmine connection config.
|
|
|
|
The API key is stored encrypted (``encryptValue`` keyed
|
|
``"redmineApiKey"``). It is never returned to the frontend in plain
|
|
text -- the route returns a boolean ``hasApiKey`` flag instead.
|
|
"""
|
|
|
|
@model_validator(mode="before")
|
|
@classmethod
|
|
def _applyDefaults(cls, values):
|
|
return _coerceNoneToDefaults(cls, values)
|
|
|
|
id: str = Field(
|
|
default_factory=lambda: str(uuid.uuid4()),
|
|
description="Primary key",
|
|
json_schema_extra={"label": "ID", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
featureInstanceId: str = Field(
|
|
description="FK -> FeatureInstance.id (1:1 per instance)",
|
|
json_schema_extra={
|
|
"label": "Feature-Instanz",
|
|
"frontend_type": "text",
|
|
"frontend_readonly": True,
|
|
"frontend_required": True,
|
|
"fk_target": {"db": "poweron_app", "table": "FeatureInstance", "labelField": "label"},
|
|
},
|
|
)
|
|
mandateId: Optional[str] = Field(
|
|
default=None,
|
|
description="Mandate ID (auto-set from feature instance)",
|
|
json_schema_extra={
|
|
"label": "Mandant",
|
|
"frontend_type": "text",
|
|
"frontend_readonly": True,
|
|
"frontend_required": False,
|
|
"fk_target": {"db": "poweron_app", "table": "Mandate", "labelField": "label"},
|
|
},
|
|
)
|
|
baseUrl: str = Field(
|
|
default="",
|
|
description="Redmine base URL, e.g. https://redmine.logobject.ch",
|
|
json_schema_extra={"label": "Basis-URL", "frontend_type": "text", "frontend_readonly": False, "frontend_required": True},
|
|
)
|
|
projectId: str = Field(
|
|
default="",
|
|
description="Redmine numeric project id or identifier (slug)",
|
|
json_schema_extra={"label": "Projekt-ID", "frontend_type": "text", "frontend_readonly": False, "frontend_required": True},
|
|
)
|
|
encryptedApiKey: str = Field(
|
|
default="",
|
|
description="Encrypted Redmine API key (X-Redmine-API-Key)",
|
|
json_schema_extra={"label": "API-Key (verschluesselt)", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False, "frontend_hidden": True},
|
|
)
|
|
rootTrackerName: str = Field(
|
|
default="Userstory",
|
|
description="Name of the tracker used as the tree root in the browser. Set explicitly in config; resolved against the live tracker list at runtime.",
|
|
json_schema_extra={"label": "Wurzel-Tracker (Name)", "frontend_type": "text", "frontend_readonly": False, "frontend_required": True},
|
|
)
|
|
defaultPeriodValue: Optional[Dict[str, Any]] = Field(
|
|
default=None,
|
|
description="Optional snapshot of a frontend ``PeriodValue`` ({preset, fromDate, toDate}) used as default period when the user opens the feature.",
|
|
json_schema_extra={"label": "Standard-Zeitraum", "frontend_type": "json", "frontend_readonly": False, "frontend_required": False},
|
|
)
|
|
schemaCache: Optional[Dict[str, Any]] = Field(
|
|
default=None,
|
|
description="Cached project meta: {trackers:[{id,name}], statuses:[{id,name,isClosed}], customFields:[{id,name,fieldFormat,possibleValues}], priorities:[...], users:[{id,name}]}",
|
|
json_schema_extra={"label": "Schema-Cache", "frontend_type": "json", "frontend_readonly": True, "frontend_required": False, "frontend_hidden": True},
|
|
)
|
|
schemaCachedAt: Optional[float] = Field(
|
|
default=None,
|
|
description="UTC timestamp when schemaCache was last refreshed",
|
|
json_schema_extra={"label": "Schema-Cache-Zeit", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
schemaCacheTtlSeconds: Optional[int] = Field(
|
|
default=24 * 60 * 60,
|
|
description="Schema cache TTL in seconds (default 24h). Optional to tolerate NULL rows from auto-DDL upgrades.",
|
|
json_schema_extra={"label": "Schema-Cache-TTL (s)", "frontend_type": "number", "frontend_readonly": False, "frontend_required": False},
|
|
)
|
|
isActive: Optional[bool] = Field(
|
|
default=True,
|
|
description="Whether this connection is active",
|
|
json_schema_extra={"label": "Aktiv", "frontend_type": "checkbox", "frontend_readonly": False, "frontend_required": False},
|
|
)
|
|
lastConnectedAt: Optional[float] = Field(
|
|
default=None,
|
|
description="Timestamp of the last successful whoAmI() call",
|
|
json_schema_extra={"label": "Letzte Verbindung", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
|
|
# ---- Sync state (incremental ticket mirror) ---------------------------
|
|
lastSyncAt: Optional[float] = Field(
|
|
default=None,
|
|
description="UTC timestamp of the last successful (incremental) mirror sync",
|
|
json_schema_extra={"label": "Letzter Sync", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
lastFullSyncAt: Optional[float] = Field(
|
|
default=None,
|
|
description="UTC timestamp of the last full mirror sync (force=true)",
|
|
json_schema_extra={"label": "Letzter Full-Sync", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
lastSyncDurationMs: Optional[int] = Field(
|
|
default=None,
|
|
description="Duration of the last sync in milliseconds",
|
|
json_schema_extra={"label": "Letzte Sync-Dauer (ms)", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
lastSyncTicketCount: Optional[int] = Field(
|
|
default=None,
|
|
description="Number of tickets upserted in the last sync",
|
|
json_schema_extra={"label": "Tickets im letzten Sync", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
lastSyncErrorAt: Optional[float] = Field(
|
|
default=None,
|
|
description="UTC timestamp of the last failed sync",
|
|
json_schema_extra={"label": "Letzter Sync-Fehler", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
lastSyncErrorMessage: Optional[str] = Field(
|
|
default=None,
|
|
description="Error message of the last failed sync",
|
|
json_schema_extra={"label": "Letzter Fehler", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
|
|
|
|
@i18nModel("Redmine-Ticket (Mirror)")
|
|
class RedmineTicketMirror(PowerOnModel):
|
|
"""Local mirror of a Redmine issue.
|
|
|
|
Composite uniqueness: ``(featureInstanceId, redmineId)``. We do not
|
|
enforce it via a DB constraint -- the sync logic looks up by these
|
|
two columns and does an upsert.
|
|
"""
|
|
|
|
@model_validator(mode="before")
|
|
@classmethod
|
|
def _applyDefaults(cls, values):
|
|
return _coerceNoneToDefaults(cls, values)
|
|
|
|
id: str = Field(
|
|
default_factory=lambda: str(uuid.uuid4()),
|
|
description="Primary key",
|
|
json_schema_extra={"label": "ID", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
featureInstanceId: str = Field(
|
|
description="FK -> FeatureInstance.id",
|
|
json_schema_extra={"label": "Feature-Instanz", "frontend_type": "text", "frontend_readonly": True, "frontend_required": True,
|
|
"fk_target": {"db": "poweron_app", "table": "FeatureInstance", "labelField": "label"}},
|
|
)
|
|
mandateId: Optional[str] = Field(
|
|
default=None,
|
|
json_schema_extra={"label": "Mandant", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
redmineId: int = Field(
|
|
description="Redmine issue id (unique per feature instance)",
|
|
json_schema_extra={"label": "Redmine-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": True},
|
|
)
|
|
subject: str = Field(default="", json_schema_extra={"label": "Titel", "frontend_type": "text", "frontend_readonly": False, "frontend_required": False})
|
|
description: str = Field(default="", json_schema_extra={"label": "Beschreibung", "frontend_type": "textarea", "frontend_readonly": False, "frontend_required": False})
|
|
trackerId: Optional[int] = Field(default=None, json_schema_extra={"label": "Tracker-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False})
|
|
trackerName: Optional[str] = Field(default=None, json_schema_extra={"label": "Tracker", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
statusId: Optional[int] = Field(default=None, json_schema_extra={"label": "Status-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False})
|
|
statusName: Optional[str] = Field(default=None, json_schema_extra={"label": "Status", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
isClosed: bool = Field(default=False, json_schema_extra={"label": "Geschlossen", "frontend_type": "checkbox", "frontend_readonly": True, "frontend_required": False})
|
|
priorityId: Optional[int] = Field(default=None, json_schema_extra={"label": "Prio-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False})
|
|
priorityName: Optional[str] = Field(default=None, json_schema_extra={"label": "Prioritaet", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
assignedToId: Optional[int] = Field(default=None, json_schema_extra={"label": "Zuweisung-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False})
|
|
assignedToName: Optional[str] = Field(default=None, json_schema_extra={"label": "Zuweisung", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
authorId: Optional[int] = Field(default=None, json_schema_extra={"label": "Autor-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False})
|
|
authorName: Optional[str] = Field(default=None, json_schema_extra={"label": "Autor", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
parentId: Optional[int] = Field(default=None, json_schema_extra={"label": "Parent-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False})
|
|
fixedVersionId: Optional[int] = Field(default=None, json_schema_extra={"label": "Zielversion-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False})
|
|
fixedVersionName: Optional[str] = Field(default=None, json_schema_extra={"label": "Zielversion", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
categoryId: Optional[int] = Field(default=None, json_schema_extra={"label": "Kategorie-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False})
|
|
categoryName: Optional[str] = Field(default=None, json_schema_extra={"label": "Kategorie", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
closedOnTs: Optional[float] = Field(
|
|
default=None,
|
|
description="Best-effort UTC epoch when the ticket transitioned to a closed status. Approximated as updatedOnTs for closed tickets at sync time; used by Stats to render the open-vs-total snapshot chart.",
|
|
json_schema_extra={"label": "closedOn (epoch)", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False, "frontend_hidden": True},
|
|
)
|
|
createdOn: Optional[str] = Field(default=None, json_schema_extra={"label": "Erstellt am (Redmine)", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
updatedOn: Optional[str] = Field(default=None, json_schema_extra={"label": "Geaendert am (Redmine)", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False})
|
|
createdOnTs: Optional[float] = Field(default=None, description="UTC epoch parsed from createdOn (for SQL filtering)",
|
|
json_schema_extra={"label": "createdOn (epoch)", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False, "frontend_hidden": True})
|
|
updatedOnTs: Optional[float] = Field(default=None, description="UTC epoch parsed from updatedOn (for SQL filtering)",
|
|
json_schema_extra={"label": "updatedOn (epoch)", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False, "frontend_hidden": True})
|
|
customFields: Optional[List[Dict[str, Any]]] = Field(
|
|
default=None,
|
|
description="List of {id,name,value} as returned by Redmine; stored as JSON",
|
|
json_schema_extra={"label": "Custom Fields", "frontend_type": "json", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
raw: Optional[Dict[str, Any]] = Field(
|
|
default=None,
|
|
description="Original Redmine issue payload (full)",
|
|
json_schema_extra={"label": "Roh-Payload", "frontend_type": "json", "frontend_readonly": True, "frontend_required": False, "frontend_hidden": True},
|
|
)
|
|
syncedAt: Optional[float] = Field(
|
|
default=None,
|
|
description="UTC epoch when this row was last upserted from Redmine",
|
|
json_schema_extra={"label": "Synced At", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
|
|
|
|
@i18nModel("Redmine-Beziehung (Mirror)")
|
|
class RedmineRelationMirror(PowerOnModel):
|
|
"""Local mirror of a Redmine issue relation.
|
|
|
|
Composite uniqueness: ``(featureInstanceId, redmineRelationId)``.
|
|
"""
|
|
|
|
@model_validator(mode="before")
|
|
@classmethod
|
|
def _applyDefaults(cls, values):
|
|
return _coerceNoneToDefaults(cls, values)
|
|
|
|
id: str = Field(
|
|
default_factory=lambda: str(uuid.uuid4()),
|
|
json_schema_extra={"label": "ID", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
featureInstanceId: str = Field(
|
|
description="FK -> FeatureInstance.id",
|
|
json_schema_extra={"label": "Feature-Instanz", "frontend_type": "text", "frontend_readonly": True, "frontend_required": True,
|
|
"fk_target": {"db": "poweron_app", "table": "FeatureInstance", "labelField": "label"}},
|
|
)
|
|
redmineRelationId: int = Field(
|
|
description="Redmine relation id (unique per feature instance)",
|
|
json_schema_extra={"label": "Relation-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": True},
|
|
)
|
|
issueId: int = Field(
|
|
description="Source issue id (issue.id from Redmine)",
|
|
json_schema_extra={"label": "Source-Issue-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": True},
|
|
)
|
|
issueToId: int = Field(
|
|
description="Target issue id (issue_to_id from Redmine)",
|
|
json_schema_extra={"label": "Target-Issue-ID", "frontend_type": "number", "frontend_readonly": True, "frontend_required": True},
|
|
)
|
|
relationType: str = Field(
|
|
default="relates",
|
|
json_schema_extra={"label": "Beziehungstyp", "frontend_type": "text", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
delay: Optional[int] = Field(
|
|
default=None,
|
|
json_schema_extra={"label": "Verzoegerung (Tage)", "frontend_type": "number", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
syncedAt: Optional[float] = Field(
|
|
default=None,
|
|
json_schema_extra={"label": "Synced At", "frontend_type": "timestamp", "frontend_readonly": True, "frontend_required": False},
|
|
)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Transport DTOs (not persisted)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class RedmineRelationDto(BaseModel):
|
|
id: int = Field(description="Relation id")
|
|
issueId: int = Field(description="Source issue id (issue.id from Redmine)")
|
|
issueToId: int = Field(description="Target issue id (issue_to_id from Redmine)")
|
|
relationType: str = Field(description="relates | precedes | follows | blocks | blocked | duplicates | duplicated | copied_to | copied_from | parent")
|
|
delay: Optional[int] = Field(default=None, description="Delay in days (precedes/follows only)")
|
|
|
|
|
|
class RedmineCustomFieldValueDto(BaseModel):
|
|
id: int
|
|
name: str
|
|
value: Any = None
|
|
|
|
|
|
class RedmineTicketDto(BaseModel):
|
|
"""Normalised Redmine issue used by the UI and the AI tools."""
|
|
|
|
id: int = Field(description="Redmine issue id")
|
|
subject: str = Field(default="")
|
|
description: str = Field(default="")
|
|
trackerId: Optional[int] = None
|
|
trackerName: Optional[str] = None
|
|
statusId: Optional[int] = None
|
|
statusName: Optional[str] = None
|
|
isClosed: bool = False
|
|
priorityId: Optional[int] = None
|
|
priorityName: Optional[str] = None
|
|
assignedToId: Optional[int] = None
|
|
assignedToName: Optional[str] = None
|
|
authorId: Optional[int] = None
|
|
authorName: Optional[str] = None
|
|
parentId: Optional[int] = None
|
|
fixedVersionId: Optional[int] = None
|
|
fixedVersionName: Optional[str] = None
|
|
categoryId: Optional[int] = None
|
|
categoryName: Optional[str] = None
|
|
createdOn: Optional[str] = None
|
|
updatedOn: Optional[str] = None
|
|
customFields: List[RedmineCustomFieldValueDto] = Field(default_factory=list)
|
|
relations: List[RedmineRelationDto] = Field(default_factory=list)
|
|
raw: Optional[Dict[str, Any]] = None
|
|
|
|
|
|
class RedmineFieldChoiceDto(BaseModel):
|
|
id: int
|
|
name: str
|
|
isClosed: Optional[bool] = Field(default=None, description="Status only: closed-state flag")
|
|
|
|
|
|
class RedmineCustomFieldSchemaDto(BaseModel):
|
|
id: int
|
|
name: str
|
|
fieldFormat: str = Field(default="string")
|
|
isRequired: bool = False
|
|
possibleValues: List[str] = Field(default_factory=list)
|
|
multiple: bool = False
|
|
defaultValue: Optional[str] = None
|
|
|
|
|
|
class RedmineFieldSchemaDto(BaseModel):
|
|
"""Project meta returned by ``getProjectMeta``."""
|
|
|
|
projectId: str
|
|
projectName: str = ""
|
|
trackers: List[RedmineFieldChoiceDto] = Field(default_factory=list)
|
|
statuses: List[RedmineFieldChoiceDto] = Field(default_factory=list)
|
|
priorities: List[RedmineFieldChoiceDto] = Field(default_factory=list)
|
|
users: List[RedmineFieldChoiceDto] = Field(default_factory=list)
|
|
categories: List[RedmineFieldChoiceDto] = Field(
|
|
default_factory=list,
|
|
description="Per-project Redmine issue categories. Empty if the project has none defined or if the API key is not allowed to list them.",
|
|
)
|
|
customFields: List[RedmineCustomFieldSchemaDto] = Field(default_factory=list)
|
|
rootTrackerName: str = "Userstory"
|
|
rootTrackerId: Optional[int] = Field(default=None, description="Resolved id of the configured rootTrackerName, or None if no matching tracker exists")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Stats DTO -- raw buckets, mapped to ReportSection in the frontend
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class RedmineStatsKpis(BaseModel):
|
|
total: int = 0
|
|
open: int = 0
|
|
closed: int = 0
|
|
closedInPeriod: int = 0
|
|
createdInPeriod: int = 0
|
|
orphans: int = 0
|
|
|
|
|
|
class RedmineStatusByTrackerEntry(BaseModel):
|
|
trackerId: Optional[int] = None
|
|
trackerName: str = ""
|
|
countsByStatus: Dict[str, int] = Field(default_factory=dict)
|
|
total: int = 0
|
|
|
|
|
|
class RedmineAssigneeBucket(BaseModel):
|
|
assignedToId: Optional[int] = None
|
|
name: str = "(nicht zugewiesen)"
|
|
open: int = 0
|
|
|
|
|
|
class RedmineRelationDistributionEntry(BaseModel):
|
|
relationType: str
|
|
count: int = 0
|
|
|
|
|
|
class RedmineAgingBucket(BaseModel):
|
|
bucketKey: str
|
|
label: str
|
|
minDays: int
|
|
maxDays: Optional[int] = None
|
|
count: int = 0
|
|
|
|
|
|
class RedmineThroughputBucket(BaseModel):
|
|
"""Per-bucket snapshot used by the Stats page.
|
|
|
|
``created`` / ``closed`` keep the per-bucket flow numbers (still useful
|
|
for callers that want raw deltas), while ``cumTotal`` / ``cumOpen``
|
|
expose the cumulative snapshot the UI actually plots:
|
|
|
|
- ``cumTotal`` = number of tickets that exist as of the END of this
|
|
bucket (= count of tickets created on or before bucket end).
|
|
- ``cumOpen`` = of those, how many are still open at bucket end (i.e.
|
|
not yet closed).
|
|
"""
|
|
|
|
bucketKey: str
|
|
label: str
|
|
created: int = 0
|
|
closed: int = 0
|
|
cumTotal: int = 0
|
|
cumOpen: int = 0
|
|
|
|
|
|
class RedmineStatsDto(BaseModel):
|
|
"""All sections needed by the Statistics page in one round-trip."""
|
|
|
|
instanceId: str
|
|
dateFrom: Optional[str] = None
|
|
dateTo: Optional[str] = None
|
|
bucket: str = "week"
|
|
trackerIds: List[int] = Field(default_factory=list)
|
|
categoryIds: List[int] = Field(default_factory=list)
|
|
statusFilter: str = "*"
|
|
|
|
kpis: RedmineStatsKpis = Field(default_factory=RedmineStatsKpis)
|
|
statusByTracker: List[RedmineStatusByTrackerEntry] = Field(default_factory=list)
|
|
throughput: List[RedmineThroughputBucket] = Field(default_factory=list)
|
|
topAssignees: List[RedmineAssigneeBucket] = Field(default_factory=list)
|
|
relationDistribution: List[RedmineRelationDistributionEntry] = Field(default_factory=list)
|
|
backlogAging: List[RedmineAgingBucket] = Field(default_factory=list)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Sync DTO
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class RedmineSyncResultDto(BaseModel):
|
|
instanceId: str
|
|
full: bool = Field(description="True if a full sync was performed (no incremental cursor)")
|
|
ticketsUpserted: int = 0
|
|
relationsUpserted: int = 0
|
|
durationMs: int = 0
|
|
lastSyncAt: float = Field(json_schema_extra={"frontend_type": "timestamp"})
|
|
error: Optional[str] = None
|
|
|
|
|
|
class RedmineSyncStatusDto(BaseModel):
|
|
instanceId: str
|
|
lastSyncAt: Optional[float] = Field(default=None, json_schema_extra={"frontend_type": "timestamp"})
|
|
lastFullSyncAt: Optional[float] = Field(default=None, json_schema_extra={"frontend_type": "timestamp"})
|
|
lastSyncDurationMs: Optional[int] = None
|
|
lastSyncTicketCount: Optional[int] = None
|
|
lastSyncErrorAt: Optional[float] = Field(default=None, json_schema_extra={"frontend_type": "timestamp"})
|
|
lastSyncErrorMessage: Optional[str] = None
|
|
mirroredTicketCount: int = 0
|
|
mirroredRelationCount: int = 0
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Request bodies
|
|
# ---------------------------------------------------------------------------
|
|
|
|
class RedmineConfigUpdateRequest(BaseModel):
|
|
"""PUT body for the config endpoint. Fields are all optional -- only
|
|
provided ones are updated. ``apiKey`` is encrypted before persistence."""
|
|
|
|
baseUrl: Optional[str] = None
|
|
projectId: Optional[str] = None
|
|
apiKey: Optional[str] = Field(default=None, description="Plain api key; will be encrypted server-side")
|
|
rootTrackerName: Optional[str] = None
|
|
defaultPeriodValue: Optional[Dict[str, Any]] = None
|
|
schemaCacheTtlSeconds: Optional[int] = None
|
|
isActive: Optional[bool] = None
|
|
|
|
|
|
class RedmineConfigDto(BaseModel):
|
|
"""Frontend-safe view of the config (no plain api key)."""
|
|
|
|
id: Optional[str] = None
|
|
featureInstanceId: str
|
|
mandateId: Optional[str] = None
|
|
baseUrl: str = ""
|
|
projectId: str = ""
|
|
hasApiKey: bool = False
|
|
rootTrackerName: str = "Userstory"
|
|
defaultPeriodValue: Optional[Dict[str, Any]] = None
|
|
schemaCacheTtlSeconds: int = 24 * 60 * 60
|
|
schemaCachedAt: Optional[float] = Field(default=None, json_schema_extra={"frontend_type": "timestamp"})
|
|
isActive: bool = True
|
|
lastConnectedAt: Optional[float] = Field(default=None, json_schema_extra={"frontend_type": "timestamp"})
|
|
lastSyncAt: Optional[float] = Field(default=None, json_schema_extra={"frontend_type": "timestamp"})
|
|
lastFullSyncAt: Optional[float] = Field(default=None, json_schema_extra={"frontend_type": "timestamp"})
|
|
lastSyncTicketCount: Optional[int] = None
|
|
lastSyncErrorMessage: Optional[str] = None
|
|
|
|
|
|
class RedmineTicketUpdateRequest(BaseModel):
|
|
"""Body for ``PUT /tickets/{id}``."""
|
|
|
|
subject: Optional[str] = None
|
|
description: Optional[str] = None
|
|
trackerId: Optional[int] = None
|
|
statusId: Optional[int] = None
|
|
priorityId: Optional[int] = None
|
|
assignedToId: Optional[int] = None
|
|
parentIssueId: Optional[int] = None
|
|
fixedVersionId: Optional[int] = None
|
|
notes: Optional[str] = None
|
|
customFields: Optional[Dict[int, Any]] = None
|
|
|
|
|
|
class RedmineTicketCreateRequest(BaseModel):
|
|
"""Body for ``POST /tickets``."""
|
|
|
|
subject: str
|
|
trackerId: int
|
|
description: Optional[str] = ""
|
|
statusId: Optional[int] = None
|
|
priorityId: Optional[int] = None
|
|
assignedToId: Optional[int] = None
|
|
parentIssueId: Optional[int] = None
|
|
fixedVersionId: Optional[int] = None
|
|
customFields: Optional[Dict[int, Any]] = None
|
|
|
|
|
|
class RedmineRelationCreateRequest(BaseModel):
|
|
"""Body for ``POST /tickets/{id}/relations``."""
|
|
|
|
issueToId: int
|
|
relationType: str = Field(default="relates")
|
|
delay: Optional[int] = None
|