diff --git a/prototypes/tests.py b/prototypes/tests.py index b6ee6a0..5894c3e 100644 --- a/prototypes/tests.py +++ b/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", diff --git a/src/wce_crm/backend/backend.py b/src/wce_crm/backend/backend.py index 228e51e..e412388 100644 --- a/src/wce_crm/backend/backend.py +++ b/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 - == db.t_ext_crm_master_attach.c.ma_id, + q_relevant_companies.c.un_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( - un_id: RecId | None, -) -> list[LinkingConsultationsEntryPerson]: - raise RuntimeError("TODOs to implement") - +def page_consulting_linking_persons() -> list[LinkingConsultationsEntryPerson]: with db.ENGINE.connect() as conn: - # if un_id None: list all persons - # else: list just the persons associated with the company - - person_select = sa.select( - db.t_grunderfassung_personen.c.pers_id, - db.t_grunderfassung_personen.c.Stammdaten__name, - db.t_grunderfassung_personen.c.Stammdaten__vorname, - db.t_grunderfassung_personen.c.Stammdaten__ort, - ) - - 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(person_select) - 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) - - linking_entries: list[LinkingConsultationsEntryPerson] = [] - for entry in person_names: - first_name = entry["Stammdaten__vorname"] - last_name = entry["Stammdaten__name"] - location_city = entry["Stammdaten__ort"] - - display_name = f"{first_name} {last_name}" - if location_city: - display_name += f" (Ort: {location_city})" - - linking_entries.append( - LinkingConsultationsEntryPerson( - pers_id=entry["pers_id"], - display_name=display_name, + 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) ) - return linking_entries + ret = conn.execute(stmt) + + persons_map: dict[str, LinkingConsultationsEntryPerson] = {} + 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] = LinkingConsultationsEntryPerson( + pers_id=p_id, + un_ids=set(), + display_name=display_name, + ) + + 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) diff --git a/src/wce_crm/data_models.py b/src/wce_crm/data_models.py index 922c425..6ce0bf0 100644 --- a/src/wce_crm/data_models.py +++ b/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) diff --git a/src/wce_crm/gui.py b/src/wce_crm/gui.py index 1fc8a6e..572571f 100644 --- a/src/wce_crm/gui.py +++ b/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" - # person_requested = Signal(Page_InitRecPerson_State) # Signal "Individualperson" - consulting_requested = Signal(Page_Consulting_State) # Signal "Beratungsgespräch" + # company_requested = Signal(Page_InitRec_State) # Signal "Unternehmen" + # person_requested = Signal(Page_InitRec_State) # Signal "Individualperson" + 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) - layout.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft) + outer_layout = QHBoxLayout(self) + 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 →") - btn_newinitrec.setFixedWidth(300) - btn_newinitrec.setFixedHeight(40) - btn_newinitrec.clicked.connect(self._request_new_initrec) + # TODO check removal + # btn_newinitrec = QPushButton("NEUE GRUNDERFASSUNG →") + # btn_newinitrec.setFixedWidth(300) + # 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.addWidget(btn_newinitrec) - layout.addSpacing(20) + # layout.addSpacing(20) + # layout.addWidget(btn_newinitrec) + # 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) - # req_state = Page_InitRecCompany_State( - # session=self.STATE.session, - # ids=ids, - # # un_id=None, # TODO remove - # locked=False, - # ) - # logger_gui.debug("[Page -- InitRec] State to call: %s", req_state) - # self.company_requested.emit(req_state) + logger_gui.debug("[Page -- NewEntry] Call for person...") + 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_initrec_person(self) -> None: logger_gui.debug("[Page -- NewEntry] Call for person...") - # ids = EntityIds(type=RecordingType.PERSON) - # req_state = Page_InitRecPerson_State( - # session=self.STATE.session, - # ids=ids, - # # pers_id=None, # TODO remove - # locked=False, - # ) - # logger_gui.debug("[Page -- InitRec] State to call: %s", req_state) - # self.person_requested.emit(req_state) + req_state = Page_InitRec_State( + session=self.STATE.session, + recording_type=RecordingType.WITHOUT_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 _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) - - 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) + self.new_consulting_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 - # self._load_companies() - # self._load_persons() - + # TODO check removal # list_style = """ # QListWidget::item:selected { # background-color: #0078D4; /* Blau, wenn die Liste aktiv fokussiert ist */ @@ -5305,20 +5286,28 @@ 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) - self.list_persons.blockSignals(True) - self._load_persons(self.STATE.un_id) - self.list_persons.blockSignals(False) + if not self.list_persons.selectedItems(): + self.list_persons.blockSignals(True) + 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["unternehmen_id"]: - # self.list_companies.blockSignals(True) - # - # for i in range(self.list_companies.count()): - # item = self.list_companies.item(i) - # 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) + if person.un_ids: + self.STATE.filter_un_ids = person.un_ids + else: + self.STATE.filter_un_ids = None + + self._sync_state_to_GUI(reset=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_initrec_requested.connect(self.show_page_newinitrec) + self.new_entry_select.new_consulting_requested.connect(self.show_page_consulting) + 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.newinitrec.back_main_requested.connect(self.show_main_page) - self.newinitrec.back_requested.connect(self.simple_go_back) - self.newinitrec.company_profile_requested.connect(self.show_page_company_profile) + self.initrec = Page_InitRec(newinitrec_state) + self.initrec.back_main_requested.connect(self.show_main_page) + self.initrec.back_requested.connect(self.simple_go_back) + 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._navigate_to_target(self.newinitrec) + self.initrec.load_state(new_state) + self._navigate_to_target(self.initrec) # def show_page_initrec_company( # self, diff --git a/src/wce_crm/logging.py b/src/wce_crm/logging.py index d011a09..7c12017 100644 --- a/src/wce_crm/logging.py +++ b/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) diff --git a/src/wce_crm/types.py b/src/wce_crm/types.py index 45d2a17..8fe1d55 100644 --- a/src/wce_crm/types.py +++ b/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