prototypes/tests.py

@@ -8,12 +8,12 @@ import json
 import re
 from collections import defaultdict
 from collections.abc import Sequence
-from pprint import pprint
+from pprint import pformat, pprint
 from typing import Annotated, Any
 
 import babel
 import polars as pl
-import sqlalchemy as sql
+import sqlalchemy as sa
 from pydantic import BaseModel, ConfigDict, EmailStr, Field, field_validator, model_validator
 from PySide6.QtCore import QDate, Qt
 
@@ -22,11 +22,81 @@ from wce_crm.backend import backend
 from wce_crm.types import EntityIds, RecordingType
 
 # %%
-empty = tuple()
+# backend.page_consulting_linking_companies(None)
+# backend.page_consulting_linking_persons(3)
 
-# not any(empty)
 
-all(empty)
+# %%
+@dc.dataclass(slots=True, kw_only=True)
+class LinkingPerson:
+    pers_id: int
+    display_name: str
+    un_ids: set[int]
+
+
+with db.ENGINE.connect() as conn:
+    # if un_id None: list all persons
+    # else: list just the persons associated with the company
+
+    stmt = (
+        sa.select(
+            db.t_grunderfassung_personen.c.pers_id,
+            db.t_zuordnung_personen_unternehmen.c.un_id,
+            db.t_grunderfassung_personen.c.Stammdaten__name,
+            db.t_grunderfassung_personen.c.Stammdaten__vorname,
+            db.t_grunderfassung_personen.c.Stammdaten__ort,
+        )
+        .outerjoin(
+            db.t_zuordnung_personen_unternehmen,
+            db.t_grunderfassung_personen.c.pers_id
+            == db.t_zuordnung_personen_unternehmen.c.pers_id,
+        )
+        .order_by(db.t_grunderfassung_personen.c.Stammdaten__name)
+    )
+
+    # if un_id is not None:
+    #     person_select = person_select.select_from(
+    #         db.t_grunderfassung_personen.join(
+    #             db.t_zuordnung_personen_unternehmen,
+    #             db.t_grunderfassung_personen.c.pers_id
+    #             == db.t_zuordnung_personen_unternehmen.c.pers_id,
+    #         )
+    #     ).where(db.t_zuordnung_personen_unternehmen.c.un_id == un_id)
+
+    ret = conn.execute(stmt)
+
+    persons_map: dict[str, Any] = {}
+    for row in ret:
+        p_id = row.pers_id
+
+        if p_id not in persons_map:
+            first_name = row.Stammdaten__vorname
+            last_name = row.Stammdaten__name
+            location_city = row.Stammdaten__ort
+
+            display_name = f"{first_name} {last_name}"
+            if location_city:
+                display_name += f" (Ort: {location_city})"
+
+            persons_map[p_id] = {
+                "pers_id": p_id,
+                "display_name": display_name,
+                "un_ids": set(),
+            }
+
+        # Falls verknüpft, ID zur Menge hinzufügen
+        if row.un_id is not None:
+            persons_map[p_id]["un_ids"].add(row.un_id)
+
+    person_names = [LinkingPerson(**data) for data in persons_map.values()]
+
+
+# person_names = ret.mappings().all()
+# if not person_names:
+#     print(f"No persons found for 'un_id': {un_id}")
+
+print(f"[Page Consulting -- Linking] Retrieved person names:\n{pformat(person_names)}")
+
 # %%
 dic = {
     "t1": "test1",

src/wce_crm/backend/backend.py

@@ -872,23 +872,18 @@ def page_consulting_from_db(
 
 
 # // consulting page interaction
-# TODO change to correct logic
 def page_consulting_linking_companies(
     un_id: RecId | None,
 ) -> list[LinkingConsultationsEntryCompany]:
-    raise RuntimeError("TODOs to implement")
-
     with db.ENGINE.connect() as conn:
         q_relevant_companies = sa.select(
             db.t_unternehmen.c.un_id,
-            db.t_unternehmen.c.Partnersuche__un_suche,
         ).where(
             db.t_unternehmen.c.geloescht.is_(None),
-            db.t_unternehmen.c.Partnersuche__un_suche.is_not(None),
         )
         if un_id is not None:
             q_relevant_companies = q_relevant_companies.where(
-                db.grunderfassung_unternehmen.c.un_id == un_id
+                db.t_unternehmen.c.un_id == un_id
             )
 
         q_relevant_companies = q_relevant_companies.subquery("relevant_companies")
@@ -899,8 +894,7 @@ def page_consulting_linking_companies(
         ).select_from(
             q_relevant_companies.join(
                 db.t_ext_crm_master_attach,
-                q_relevant_companies.c.Partnersuche__un_suche
+                q_relevant_companies.c.un_id == db.t_ext_crm_master_attach.c.ma_id,
-                == db.t_ext_crm_master_attach.c.ma_id,
             )
         )
 
@@ -923,57 +917,49 @@ def page_consulting_linking_companies(
     return linking_entries
 
 
-def page_consulting_linking_persons(
+def page_consulting_linking_persons() -> list[LinkingConsultationsEntryPerson]:
-    un_id: RecId | None,
-) -> list[LinkingConsultationsEntryPerson]:
-    raise RuntimeError("TODOs to implement")
-
     with db.ENGINE.connect() as conn:
-        # if un_id None: list all persons
+        stmt = (
-        # else: list just the persons associated with the company
+            sa.select(
-
-        person_select = sa.select(
                 db.t_grunderfassung_personen.c.pers_id,
+                db.t_zuordnung_personen_unternehmen.c.un_id,
                 db.t_grunderfassung_personen.c.Stammdaten__name,
                 db.t_grunderfassung_personen.c.Stammdaten__vorname,
                 db.t_grunderfassung_personen.c.Stammdaten__ort,
             )
-
+            .outerjoin(
-        if un_id is not None:
-            person_select = person_select.select_from(
-                db.t_grunderfassung_personen.join(
                 db.t_zuordnung_personen_unternehmen,
                 db.t_grunderfassung_personen.c.pers_id
                 == db.t_zuordnung_personen_unternehmen.c.pers_id,
             )
-            ).where(db.t_zuordnung_personen_unternehmen.c.un_id == un_id)
+            .order_by(db.t_grunderfassung_personen.c.Stammdaten__name)
+        )
 
-        ret = conn.execute(person_select)
+        ret = conn.execute(stmt)
-        person_names = ret.mappings().all()
-        if not person_names:
-            logger.warning(f"No persons found for 'un_id': {un_id}")
-            return []
 
-    logger.debug("[Page Consulting -- Linking] Retrieved person names:\n%s", person_names)
+        persons_map: dict[str, LinkingConsultationsEntryPerson] = {}
+        for row in ret:
+            p_id = row.pers_id
 
-    linking_entries: list[LinkingConsultationsEntryPerson] = []
+            if p_id not in persons_map:
-    for entry in person_names:
+                first_name = row.Stammdaten__vorname
-        first_name = entry["Stammdaten__vorname"]
+                last_name = row.Stammdaten__name
-        last_name = entry["Stammdaten__name"]
+                location_city = row.Stammdaten__ort
-        location_city = entry["Stammdaten__ort"]
 
                 display_name = f"{first_name} {last_name}"
                 if location_city:
                     display_name += f" (Ort: {location_city})"
 
-        linking_entries.append(
+                persons_map[p_id] = LinkingConsultationsEntryPerson(
-            LinkingConsultationsEntryPerson(
+                    pers_id=p_id,
-                pers_id=entry["pers_id"],
+                    un_ids=set(),
                     display_name=display_name,
                 )
-        )
 
-    return linking_entries
+            if row.un_id is not None:
+                persons_map[p_id].un_ids.add(row.un_id)
+
+    return list(persons_map.values())
 
 
 # TODO wrap result
@@ -982,8 +968,6 @@ def page_consulting_eastablish_link(
     un_id: RecId | None,
     pers_id: RecId | None,
 ) -> None:
-    raise RuntimeError("TODOs to implement")
-
     stmt = (
         sa.update(db.t_beratung_vorgang)
         .where(db.t_beratung_vorgang.c.vorgang_id == vorgang_id)

src/wce_crm/data_models.py

@@ -124,36 +124,6 @@ class Module(WrapperModule, Protocol):
     def save_data(self) -> None: ...
 
 
-# TODO check removal
-# class AutoFormInsert(Protocol):
-#     def __call__(
-#         self,
-#         data: dict[str, Any],
-#     ) -> RecId: ...
-
-
-# class AutoFormUpdate(Protocol):
-#     def __call__(
-#         self,
-#         id_: int,
-#         data: dict[str, Any],
-#     ) -> None: ...
-
-
-# class AutoFormGet(Protocol):
-#     def __call__(
-#         self,
-#         id_: int,
-#     ) -> dict[str, Any]: ...
-
-
-# class AutoFormDelete(Protocol):
-#     def __call__(
-#         self,
-#         id_: int,
-#     ) -> None: ...
-
-
 class InitRecFormToDb(Protocol):
     def __call__(
         self,
@@ -222,24 +192,6 @@ class Page_NewEntry_State(PageState[Module]):
     session: Session
 
 
-# TODO check removal
-# INITREC_REC_TO_ENTITIES: Final[dict[RecordingType, frozenset[EntityType]]] = {
-#     RecordingType.WITH_COMPANY: frozenset(
-#         (
-#             EntityType.METADATA,
-#             EntityType.COMPANY,
-#             EntityType.PERSON,
-#         )
-#     ),
-#     RecordingType.WITHOUT_COMPANY: frozenset(
-#         (
-#             EntityType.METADATA,
-#             EntityType.PERSON,
-#         )
-#     ),
-# }
-
-
 @dc.dataclass(slots=True, kw_only=True)
 class Page_InitRec_Form_Data:
     metadata: dict[str, Any]
@@ -260,11 +212,8 @@ class Page_InitRec_State(PageState["InitRecForm"]):
     initrec_form_states: dict[EntityType, Page_InitRec_Form_State] = dc.field(
         init=False, default_factory=dict
     )
-    # pydantic_models: dict[RecordingType, type[FlatBaseModel]] = dc.field(default_factory=dict)
 
     def __post_init__(self) -> None:
-        # TODO check removal
-        # relevant_entities = INITREC_REC_TO_ENTITIES[self.recording_type]
         relevant_entities = frozenset(
             (
                 EntityType.METADATA,
@@ -306,24 +255,6 @@ class Page_InitRec_Form_State(PageState[Module]):
     geloescht: bool = False
 
 
-# TODO remove
-# @dc.dataclass(slots=True, kw_only=True)
-# class Page_InitRecCompany_State(PageState[Module]):
-#     session: Session
-#     ids: EntityIds
-#     # un_id: RecId | None = None
-#     locked: bool
-
-
-# @dc.dataclass(slots=True, kw_only=True)
-# class Page_InitRecPerson_State(PageState[Module]):
-#     session: Session
-#     ids: EntityIds
-#     # pers_id: RecId | None = None
-#     # un_id: RecId | None = None
-#     locked: bool
-
-
 @dc.dataclass(slots=True, kw_only=True)
 class Page_Consulting_State(PageState[Module]):
     session: Session
@@ -345,6 +276,7 @@ class Page_Consulting_Linking_State(PageState[Module]):
     un_id: RecId | None = None
     pers_id: RecId | None = None
     beratungs_typ: ConsultingType
+    filter_un_ids: set[RecId] | None = None
 
 
 @dc.dataclass(slots=True, kw_only=True)

src/wce_crm/gui.py

@@ -2907,9 +2907,9 @@ class Page_NewEntry(QWidget):
 
     back_requested = Signal()  # Signal back button
     # TODO re-enable with correct settings
-    # company_requested = Signal(Page_InitRecCompany_State)  # Signal "Unternehmen"
+    # company_requested = Signal(Page_InitRec_State)  # Signal "Unternehmen"
-    # person_requested = Signal(Page_InitRecPerson_State)  # Signal "Individualperson"
+    # person_requested = Signal(Page_InitRec_State)  # Signal "Individualperson"
-    consulting_requested = Signal(Page_Consulting_State)  # Signal "Beratungsgespräch"
+    new_consulting_requested = Signal(Page_Consulting_State)  # Signal "Beratungsgespräch"
     new_initrec_requested = Signal(Page_InitRec_State)  # TODO: rename
 
     def __init__(
@@ -2919,75 +2919,101 @@ class Page_NewEntry(QWidget):
         super().__init__()
         self.STATE = state
 
-        layout = QVBoxLayout(self)
+        outer_layout = QHBoxLayout(self)
-        layout.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft)
+        layout_container = QWidget()
+        layout_container.setMinimumWidth(700)
+        layout_container.setMaximumWidth(1000)
+        layout = QVBoxLayout(layout_container)
+
+        outer_layout.addStretch(1)
+        outer_layout.addWidget(layout_container, stretch=100)
+        # outer_layout.addWidget(scroll_area, stretch=100)
+        outer_layout.addStretch(1)
+        outer_layout.setAlignment(Qt.AlignmentFlag.AlignTop)
 
-        # Zurück-Button
         back_btn = QPushButton("← Zurück zur Übersicht")
         back_btn.setFixedWidth(200)
         back_btn.clicked.connect(lambda: self.back_requested.emit())
 
-        # Platzhalter für die Details
         self.title_label = QLabel("Wählen Sie den Typ der Grunderfassung")
         self.title_label.setStyleSheet(
             "font-size: 24px; font-weight: bold; margin-top: 20px;"
         )
 
+        title_initrec = QLabel("Grunderfassung anlegen")
+        title_initrec.setStyleSheet(
+            "font-size: 16px; font-weight: bold; margin-top: 20px; margin-bottom: 5px;"
+        )
         btn_company = QPushButton("Unternehmen →")
         btn_company.setFixedWidth(300)
         btn_company.setFixedHeight(40)
         btn_company.clicked.connect(self._request_initrec_company)
-
         btn_person = QPushButton("Individualperson →")
         btn_person.setFixedWidth(300)
         btn_person.setFixedHeight(40)
         btn_person.clicked.connect(self._request_initrec_person)
 
+        title_consulting = QLabel("Beratung durchführen")
+        title_consulting.setStyleSheet(
+            "font-size: 16px; font-weight: bold; margin-top: 20px; margin-bottom: 5px;"
+        )
         btn_consulting = QPushButton("Beratungsgespräch →")
         btn_consulting.setFixedWidth(300)
         btn_consulting.setFixedHeight(40)
         btn_consulting.clicked.connect(self._request_consulting)
 
-        btn_newinitrec = QPushButton("NEUE GRUNDERFASSUNG →")
+        # TODO check removal
-        btn_newinitrec.setFixedWidth(300)
+        # btn_newinitrec = QPushButton("NEUE GRUNDERFASSUNG →")
-        btn_newinitrec.setFixedHeight(40)
+        # btn_newinitrec.setFixedWidth(300)
-        btn_newinitrec.clicked.connect(self._request_new_initrec)
+        # btn_newinitrec.setFixedHeight(40)
+        # btn_newinitrec.clicked.connect(self._debug_request_new_initrec)
 
         layout.addWidget(back_btn)
         layout.addSpacing(15)
         layout.addWidget(self.title_label)
-        layout.addSpacing(20)
+        # layout.addSpacing(20)
-        layout.addWidget(btn_newinitrec)
+        # layout.addWidget(btn_newinitrec)
-        layout.addSpacing(20)
+        # layout.addSpacing(20)
+        layout.addWidget(title_initrec)
         layout.addWidget(btn_company)
         layout.addWidget(btn_person)
         layout.addSpacing(10)
+        layout.addWidget(title_consulting)
         layout.addWidget(btn_consulting)
 
     # TODO configure correctly
     def _request_initrec_company(self) -> None:
         logger_gui.debug("[Page -- NewEntry] Call for company...")
-        # ids = EntityIds(type=RecordingType.COMPANY)
+        logger_gui.debug("[Page -- NewEntry] Call for person...")
-        # req_state = Page_InitRecCompany_State(
+        req_state = Page_InitRec_State(
-        #     session=self.STATE.session,
+            session=self.STATE.session,
-        #     ids=ids,
+            recording_type=RecordingType.WITH_COMPANY,
-        #     # un_id=None, # TODO remove
+            form_data=Page_InitRec_Form_Data(metadata={}, person={}, company={}),
-        #     locked=False,
+            locked=False,
-        # )
+        )
-        # logger_gui.debug("[Page -- InitRec] State to call: %s", req_state)
+        logger_gui.debug("[Page -- NewEntry] State to call (IDs): %s", req_state.ids)
-        # self.company_requested.emit(req_state)
+        self.new_initrec_requested.emit(req_state)
 
     def _request_initrec_person(self) -> None:
         logger_gui.debug("[Page -- NewEntry] Call for person...")
-        # ids = EntityIds(type=RecordingType.PERSON)
+        req_state = Page_InitRec_State(
-        # req_state = Page_InitRecPerson_State(
+            session=self.STATE.session,
-        #     session=self.STATE.session,
+            recording_type=RecordingType.WITHOUT_COMPANY,
-        #     ids=ids,
+            form_data=Page_InitRec_Form_Data(metadata={}, person={}, company={}),
-        #     # pers_id=None, # TODO remove
+            locked=False,
-        #     locked=False,
+        )
-        # )
+        logger_gui.debug("[Page -- NewEntry] State to call (IDs): %s", req_state.ids)
-        # logger_gui.debug("[Page -- InitRec] State to call: %s", req_state)
+        self.new_initrec_requested.emit(req_state)
-        # self.person_requested.emit(req_state)
+
+    def _debug_request_new_initrec(self) -> None:
+        req_state = Page_InitRec_State(
+            session=self.STATE.session,
+            recording_type=RecordingType.WITH_COMPANY,
+            form_data=Page_InitRec_Form_Data(metadata={}, person={}, company={}),
+            locked=False,
+        )
+        logger_gui.debug("[Page -- NewEntry] State to call (IDs): %s", req_state.ids)
+        self.new_initrec_requested.emit(req_state)
 
     def _request_consulting(self) -> None:
         req_state = Page_Consulting_State(
@@ -2997,17 +3023,7 @@ class Page_NewEntry(QWidget):
             locked=False,
         )
         logger_gui.debug("[Page -- InitRec] State to call: %s", req_state)
-        self.consulting_requested.emit(req_state)
+        self.new_consulting_requested.emit(req_state)
-
-    def _request_new_initrec(self) -> None:
-        req_state = Page_InitRec_State(
-            session=self.STATE.session,
-            recording_type=RecordingType.WITH_COMPANY,
-            form_data=Page_InitRec_Form_Data(metadata={}, person={}, company={}),
-            locked=False,
-        )
-        logger_gui.debug("[Page -- NewInitRec] State to call (IDs): %s", req_state.ids)
-        self.new_initrec_requested.emit(req_state)
 
     def _sync_state_to_GUI(self) -> None:
         pass
@@ -5177,46 +5193,14 @@ class Page_Consulting_LinkingDialog(QDialog):
         parent: QWidget | None = None,
     ):
         super().__init__(parent)
+        # State and data
         self.STATE = state
+        self.all_companies = backend.page_consulting_linking_companies(None)
+        self.all_persons = backend.page_consulting_linking_persons()
 
         self.setWindowTitle("Beziehung verknüpfen")
         self.resize(700, 450)
 
-        # firmen_aus_db = [{"id": 1, "name": "Siemens AG"}, {"id": 2, "name": "Bosch GmbH"}]
-        # personen_aus_db = [
-        #     {
-        #         "id": 50,
-        #         "name": "Max Mustermann",
-        #         "unternehmen_id": 1,
-        #         "firma_name": "Siemens AG",
-        #     },
-        #     {
-        #         "id": 51,
-        #         "name": "Erika Muster",
-        #         "unternehmen_id": 1,
-        #         "firma_name": "Siemens AG",
-        #     },
-        #     {
-        #         "id": 52,
-        #         "name": "Peter Müller",
-        #         "unternehmen_id": 2,
-        #         "firma_name": "Bosch GmbH",
-        #     },
-        #     {
-        #         "id": 53,
-        #         "name": "Freiberufler Frank",
-        #         "unternehmen_id": None,
-        #         "firma_name": None,
-        #     },
-        # ]
-
-        # self.all_unternehmen = firmen_aus_db
-        # self.all_personen = personen_aus_db
-
-        # # Rückgabewerte
-        # self.gewaehltes_unternehmen = None
-        # self.gewaehlte_person = None
-
         # --- UI LAYOUT ---
         main_layout = QVBoxLayout(self)
         column_layout = QHBoxLayout()
@@ -5241,7 +5225,7 @@ class Page_Consulting_LinkingDialog(QDialog):
         column_layout.addLayout(self.vbox_persons)
         main_layout.addLayout(column_layout)
 
-        # Unten: OK / Abbrechen Buttons
+        # OK / Cancel buttons
         self.button_box = QDialogButtonBox(
             QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
         )
@@ -5251,10 +5235,7 @@ class Page_Consulting_LinkingDialog(QDialog):
         self.button_box.button(QDialogButtonBox.StandardButton.Cancel).setText("Abbrechen")
         main_layout.addWidget(self.button_box)
 
-        # initial loading
+        # TODO check removal
-        # self._load_companies()
-        # self._load_persons()
-
         # list_style = """
         #     QListWidget::item:selected {
         #         background-color: #0078D4;  /* Blau, wenn die Liste aktiv fokussiert ist */
@@ -5305,21 +5286,29 @@ class Page_Consulting_LinkingDialog(QDialog):
     def _sync_state_to_GUI(
         self,
         reset: bool,
-        section: Literal["person_selection", "validation"] | None = None,
+        section: Literal["person_selection", "company_selection", "validation"] | None = None,
     ) -> None:
         if reset:
             self._reset()
-            self._load_companies()
+            self._load_companies_to_list(None)
+            self._load_persons_to_list(None)
 
         if section is None or section == "person_selection":
             if self.STATE.beratungs_typ is ConsultingType.PAUSCHAL:
                 self._enable_person_selection(False)
             elif self.STATE.beratungs_typ is ConsultingType.INDIVIDUAL:
                 self._enable_person_selection(True)
+                if not self.list_persons.selectedItems():
                     self.list_persons.blockSignals(True)
-                self._load_persons(self.STATE.un_id)
+                    self._load_persons_to_list(self.STATE.un_id)
                     self.list_persons.blockSignals(False)
 
+        if section is None or section == "company_selection":
+            if not self.list_companies.selectedItems():
+                self.list_companies.blockSignals(True)
+                self._load_companies_to_list(self.STATE.filter_un_ids)
+                self.list_companies.blockSignals(False)
+
         if section is None or section == "validation":
             self._validate()
 
@@ -5341,31 +5330,49 @@ class Page_Consulting_LinkingDialog(QDialog):
         else:
             self.ok_btn.setEnabled(False)
 
-    def _load_companies(self) -> None:
+    def _reload_all_companies(self) -> None:
+        self.all_companies = backend.page_consulting_linking_companies(None)
+
+    def _reload_all_persons(self) -> None:
+        self.all_persons = backend.page_consulting_linking_persons()
+
+    def _load_companies_to_list(
+        self,
+        un_ids: set[RecId] | None,
+    ) -> None:
+        # search_text = self.suche_firma.text().strip().lower()
         self.list_companies.clear()
-        companies = backend.page_consulting_linking_companies(un_id=self.STATE.un_id)
+        # TODO check reload of companies
+        # companies = backend.page_consulting_linking_companies(None)
         logger_page_consulting.debug(
-            "[Page Consulting -- Linking] Retrieved company entries:\n%s", companies
+            "[Page Consulting -- Linking] Retrieved company entries:\n%s", self.all_companies
         )
 
-        for company in companies:
+        for company in self.all_companies:
+            if un_ids and company.un_id not in un_ids:
+                continue
+
             item = QListWidgetItem(company.display_name)
             item.setData(Qt.ItemDataRole.UserRole, company)
             self.list_companies.addItem(item)
 
-    def _load_persons(
+    def _load_persons_to_list(
         self,
         un_id: RecId | None,
     ) -> None:
         """Lädt Personen. Wenn firma_id übergeben wird, wird gefiltert."""
         self.list_persons.clear()
 
-        persons = backend.page_consulting_linking_persons(un_id)
+        # TODO check reload of persons
+        # persons = backend.page_consulting_linking_persons()
         logger_page_consulting.debug(
-            "[Page Consulting -- Linking] Retrieved person entries:\n%s", persons
+            "[Page Consulting -- Linking] Retrieved person entries:\n%s", self.all_persons
         )
 
-        for person in persons:
+        for person in self.all_persons:
+            if un_id and un_id not in person.un_ids:
+                continue
+
             item = QListWidgetItem(person.display_name)
             item.setData(Qt.ItemDataRole.UserRole, person)
             self.list_persons.addItem(item)
@@ -5386,10 +5393,6 @@ class Page_Consulting_LinkingDialog(QDialog):
             pformat(self.STATE),
         )
         self._sync_state_to_GUI(reset=False)
-        # if self.STATE.beratungs_typ is ConsultingType.INDIVIDUAL:
-        #     self.list_persons.blockSignals(True)
-        #     self._load_persons(un_id=self.STATE.un_id)
-        #     self.list_persons.blockSignals(False)
 
     def _person_selected(self) -> None:
         items = self.list_persons.selectedItems()
@@ -5400,29 +5403,29 @@ class Page_Consulting_LinkingDialog(QDialog):
             "LinkingConsultationsEntryPerson", items[0].data(Qt.ItemDataRole.UserRole)
         )
         self.STATE.pers_id = person.pers_id
-        self._sync_state_to_GUI(reset=False, section="validation")
 
-        # TODO this backlink is a really good idea and should be implemented
+        if person.un_ids:
-        # if person["unternehmen_id"]:
+            self.STATE.filter_un_ids = person.un_ids
-        #     self.list_companies.blockSignals(True)
+        else:
-        #
+            self.STATE.filter_un_ids = None
-        #     for i in range(self.list_companies.count()):
+
-        #         item = self.list_companies.item(i)
+        self._sync_state_to_GUI(reset=False)
-        #         firma_data = item.data(Qt.ItemDataRole.UserRole)
-        #         if firma_data["id"] == person["unternehmen_id"]:
-        #             item.setSelected(True)
-        #             self.gewaehltes_unternehmen = firma_data
-        #             break
-        #     self.list_companies.blockSignals(False)
 
     def _clear_company_selection(self) -> None:
+        logger_page_consulting.debug(
+            "[Page Consulting -- Linking] Clear company selection...",
+        )
         self.list_companies.clearSelection()
         self.STATE.un_id = None
         self._sync_state_to_GUI(reset=False)
 
     def _clear_person_selection(self) -> None:
+        logger_page_consulting.debug(
+            "[Page Consulting -- Linking] Clear person selection...",
+        )
         self.list_persons.clearSelection()
         self.STATE.pers_id = None
+        self.STATE.filter_un_ids = None
         self._sync_state_to_GUI(reset=False)
 
     def get_state(self) -> Page_Consulting_Linking_State:
@@ -6220,8 +6223,8 @@ class MainWindow(QMainWindow):
         self.new_entry_select.back_requested.connect(self.show_main_page)
         # self.new_initrec_select.company_requested.connect(self.show_page_initrec_company)
         # self.new_initrec_select.person_requested.connect(self.show_page_initrec_person)
-        self.new_entry_select.consulting_requested.connect(self.show_page_consulting)
+        self.new_entry_select.new_consulting_requested.connect(self.show_page_consulting)
-        self.new_entry_select.new_initrec_requested.connect(self.show_page_newinitrec)
+        self.new_entry_select.new_initrec_requested.connect(self.show_page_initrec)
         self.stack.addWidget(self.new_entry_select)
 
         # SITE: 'Grunderfassung'
@@ -6232,35 +6235,13 @@ class MainWindow(QMainWindow):
             form_data=Page_InitRec_Form_Data(metadata={}, person={}, company={}),
             locked=False,
         )
-        self.newinitrec = Page_InitRec(newinitrec_state)
+        self.initrec = Page_InitRec(newinitrec_state)
-        self.newinitrec.back_main_requested.connect(self.show_main_page)
+        self.initrec.back_main_requested.connect(self.show_main_page)
-        self.newinitrec.back_requested.connect(self.simple_go_back)
+        self.initrec.back_requested.connect(self.simple_go_back)
-        self.newinitrec.company_profile_requested.connect(self.show_page_company_profile)
+        self.initrec.company_profile_requested.connect(self.show_page_company_profile)
         # self.newinitrec.update_triggered.connect(self.update_grid)
-        self.stack.addWidget(self.newinitrec)
+        self.stack.addWidget(self.initrec)
 
-        # SITE: 'Grunderfassung Unternehmen'
-        # ids = EntityIds(type=RecordingType.COMPANY)
-        # initrec_company_state = Page_InitRecCompany_State(
-        #     session=self.STATE.session, ids=ids, locked=False
-        # )
-        # self.initrec_company = Page_InitRecCompany(initrec_company_state)
-        # self.initrec_company.back_main_requested.connect(self.show_main_page)
-        # self.initrec_company.back_requested.connect(self.simple_go_back)
-        # self.initrec_company.update_main_page.connect(self.update_grid)
-        # self.initrec_company.initrec_person_requested.connect(self.show_page_initrec_person)
-        # self.initrec_company.company_profile_requested.connect(self.show_page_company_profile)
-        # self.stack.addWidget(self.initrec_company)
-        # SITE: 'Grunderfassung Person'
-        # ids = EntityIds(type=RecordingType.PERSON)
-        # initrec_person_state = Page_InitRecPerson_State(
-        #     session=self.STATE.session, ids=ids, locked=False
-        # )
-        # self.initrec_person = Page_InitRecPerson(initrec_person_state)
-        # self.initrec_person.back_main_requested.connect(self.show_main_page)
-        # self.initrec_person.back_requested.connect(self.simple_go_back)
-        # self.initrec_person.update_triggered.connect(self.update_grid)
-        # self.stack.addWidget(self.initrec_person)
         # SITE: 'Unternehmensprofil'
         comp_profile_state = Page_CompanyProfile_State(session=self.STATE.session)
         self.company_profile = Page_CompanyProfile(comp_profile_state)
@@ -6270,6 +6251,7 @@ class MainWindow(QMainWindow):
         self.company_profile.back_requested.connect(self.simple_go_back)
         self.company_profile.consulting_requested.connect(self.show_page_consulting)
         self.stack.addWidget(self.company_profile)
+
         # SITE: 'Beratungsgespräch'
         self.consulting_page = Page_Consulting(self.STATE.session)
         self.consulting_page.back_main_requested.connect(self.show_main_page)
@@ -6452,12 +6434,12 @@ class MainWindow(QMainWindow):
     def show_new_entry_select(self):
         self._navigate_to_target(self.new_entry_select)
 
-    def show_page_newinitrec(
+    def show_page_initrec(
         self,
         new_state: Page_InitRec_State,
     ):
-        self.newinitrec.load_state(new_state)
+        self.initrec.load_state(new_state)
-        self._navigate_to_target(self.newinitrec)
+        self._navigate_to_target(self.initrec)
 
     # def show_page_initrec_company(
     #     self,

src/wce_crm/logging.py

@@ -41,7 +41,7 @@ logger_custom_fields = logger_gui.getChild("custom_fields")
 logger_custom_fields.setLevel(logging.WARNING)
 
 logger_page_consulting = logger_gui.getChild("page_consulting")
-logger_page_consulting.setLevel(logging.WARNING)
+logger_page_consulting.setLevel(logging.DEBUG)
 
 logger_page_initrec = logger_gui.getChild("page_initrec")
 logger_page_initrec.setLevel(logging.DEBUG)

src/wce_crm/types.py

@@ -273,4 +273,5 @@ class LinkingConsultationsEntryCompany:
 @dc.dataclass(slots=True)
 class LinkingConsultationsEntryPerson:
     pers_id: RecId
+    un_ids: set[RecId]
     display_name: str