Files

173 lines
6.7 KiB
Python

"""
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)