""" Groups Service - Geschäftslogik für Gruppen mit In-Memory-Caching """ from cmbnet.models.groups import GroupModel from cmbnet.models.streets import StreetModel from cmbnet.models.accounts import AccountModel from cmbnet.db import get_db class GroupsService: # In-Memory Cache: groups_cache[tenant_id][group_id] = group_dict _cache = {} # Gemeinsame Cache-Revision je Mandant. Sie liegt in der Tabelle # ``cache_state`` und wird bei jeder schreibenden Änderung erhöht. Dadurch # verwirft jeder Worker seinen lokalen Cache, sobald ein anderer Worker # Gruppen- oder Zuordnungsdaten geändert hat. _cache_revision = {} @classmethod def _revision_key(cls, tenant_id): return f'groups:{tenant_id}' @classmethod def _current_revision(cls, tenant_id): db = get_db() key = cls._revision_key(tenant_id) row = db.execute( 'SELECT revision FROM cache_state WHERE key = ?', (key,) ).fetchone() if row is None: db.execute( 'INSERT OR IGNORE INTO cache_state (key, revision) VALUES (?, 0)', (key,) ) db.commit() return 0 return int(row['revision'] or 0) @classmethod def _bump_revision(cls, tenant_id): """Erhöht die gemeinsame Revision und gibt den neuen Wert zurück.""" db = get_db() key = cls._revision_key(tenant_id) db.execute( 'INSERT OR IGNORE INTO cache_state (key, revision) VALUES (?, 0)', (key,) ) db.execute( 'UPDATE cache_state SET revision = revision + 1, ' 'updated_at = CURRENT_TIMESTAMP WHERE key = ?', (key,) ) row = db.execute( 'SELECT revision FROM cache_state WHERE key = ?', (key,) ).fetchone() db.commit() return int(row['revision'] or 0) @classmethod def load_from_db(cls, tenant_id): """Lädt alle Gruppen eines Mandanten aus der Datenbank in den Cache""" # Revision vor dem Lesen der Daten ermitteln. Schreibt ein anderer # Worker währenddessen, bleibt die gespeicherte Revision älter als die # gemeinsame Revision und der Cache wird beim nächsten Zugriff erneut # geladen. Die umgekehrte Reihenfolge könnte dagegen veraltete Daten # dauerhaft mit einer aktuellen Revision verknüpfen. revision = cls._current_revision(tenant_id) groups = GroupModel.get_all_by_tenant(tenant_id) memberships = GroupModel.get_account_ids_by_group(tenant_id) # Vollständig neu aufbauen, damit gelöschte Gruppen nicht im Cache # zurückbleiben. cls._cache[tenant_id] = {} for group in groups: cls._cache[tenant_id][group['id']] = { 'id': group['id'], 'tenant_id': group['tenant_id'], 'aliasname': group['aliasname'], 'state': group['state'], 'last_lat': group['last_lat'], 'last_lon': group['last_lon'], 'last_pos_at': group['last_pos_at'], 'account_ids': memberships.get(group['id'], []), 'created_at': group['created_at'], 'updated_at': group['updated_at'] } cls._cache_revision[tenant_id] = revision return cls._cache[tenant_id] @classmethod def get_all(cls, tenant_id, force_reload=False): """Gibt alle Gruppen für einen Mandanten zurück (aus Cache)""" revision = cls._current_revision(tenant_id) if ( force_reload or tenant_id not in cls._cache or not cls._cache[tenant_id] or cls._cache_revision.get(tenant_id) != revision ): cls.load_from_db(tenant_id) return cls._cache.get(tenant_id, {}) @classmethod def get_by_id(cls, tenant_id, group_id): """Gibt eine spezifische Gruppe aus dem Cache zurück""" revision = cls._current_revision(tenant_id) if ( tenant_id not in cls._cache or not cls._cache[tenant_id] or cls._cache_revision.get(tenant_id) != revision ): cls.load_from_db(tenant_id) return cls._cache.get(tenant_id, {}).get(group_id) @classmethod def invalidate(cls, tenant_id): """Invalidiert den Cache für einen Mandanten (erzwingt Neuladen).""" if tenant_id in cls._cache: cls._cache[tenant_id] = {} cls._cache_revision.pop(tenant_id, None) cls._bump_revision(tenant_id) @classmethod def invalidate_all(cls): """Invalidiert den gesamten Cache.""" cls._cache = {} cls._cache_revision = {} @classmethod def is_account_linked(cls, account_id, group_id, tenant_id): """Prüft, ob ein Account mit einer Gruppe verknüpft ist""" group = cls.get_by_id(tenant_id, group_id) if not group: return False account_ids = {int(value) for value in group.get('account_ids', [])} return int(account_id) in account_ids @classmethod def get_accounts_for_group(cls, group_id, tenant_id): """Gibt alle mit einer Gruppe verknüpften Accounts zurück""" account_ids = GroupModel.get_account_ids_for_group(group_id, tenant_id) accounts = [] for account_id in account_ids: account = AccountModel.get_by_id(account_id, tenant_id) if account: accounts.append(account) return accounts @classmethod def get_streets_for_group(cls, group_id, tenant_id): """Gibt alle mit einer Gruppe verknüpften Straßen zurück""" return StreetModel.get_by_group_id(group_id, tenant_id) @classmethod def update_cache_entry(cls, tenant_id, group_id, data): """Aktualisiert einen Eintrag im Cache und invalidiert andere Worker. Der Cache wird vor dem Aktualisieren vollständig geladen, damit ein gezieltes Update (z. B. nach Code 200/300) keinen Teil-Cache erzeugt, der anschließend beim Initialload unvollständige Gruppendaten liefert. Anschließend wird die gemeinsame Revision erhöht, damit andere Worker ihre lokalen Caches verwerfen. Der lokale Cache wird bewusst nicht auf die neue Revision gesetzt: Beim nächsten Zugriff wird er neu geladen und kann so keine Änderungen verpassen, die ein anderer Worker zwischen dem Laden und dem Erhöhen der Revision geschrieben hat. """ cls.get_all(tenant_id) if group_id not in cls._cache[tenant_id]: cls._cache[tenant_id][group_id] = {} cls._cache[tenant_id][group_id].update(data) cls._bump_revision(tenant_id) cls._cache_revision.pop(tenant_id, None)