|
|
# -*- coding: utf-8 -*-
|
|
|
"""ITD - общ модул за връзка и зареждане на данни от базата."""
|
|
|
|
|
|
import json
|
|
|
import os
|
|
|
from datetime import datetime, timezone
|
|
|
|
|
|
try:
|
|
|
import pyodbc
|
|
|
except ImportError:
|
|
|
pyodbc = None
|
|
|
|
|
|
|
|
|
_LAST_APPSETTINGS_PATH = None
|
|
|
_LAST_CONNECTION_STRING_REDACTED = None
|
|
|
|
|
|
|
|
|
def get_last_appsettings_path():
|
|
|
"""Връща пълния път към последно намерения appsettings.json (или None)."""
|
|
|
return _LAST_APPSETTINGS_PATH
|
|
|
|
|
|
|
|
|
def get_last_connection_string_redacted():
|
|
|
"""Връща последно използвания connection string с маскирани пароли (или None)."""
|
|
|
return _LAST_CONNECTION_STRING_REDACTED
|
|
|
|
|
|
|
|
|
def _redact_conn_str(s: str) -> str:
|
|
|
if not s:
|
|
|
return s
|
|
|
redacted_parts = []
|
|
|
for part in str(s).split(";"):
|
|
|
p = part.strip()
|
|
|
if not p:
|
|
|
continue
|
|
|
if "=" not in p:
|
|
|
redacted_parts.append(p)
|
|
|
continue
|
|
|
k, v = p.split("=", 1)
|
|
|
kl = k.strip().lower()
|
|
|
if kl in ("pwd", "password"):
|
|
|
redacted_parts.append(f"{k}=***")
|
|
|
else:
|
|
|
redacted_parts.append(f"{k}={v}")
|
|
|
return ";".join(redacted_parts) + ";"
|
|
|
|
|
|
|
|
|
def load_connection_string():
|
|
|
"""Зарежда connection string от appsettings.json."""
|
|
|
import sys
|
|
|
|
|
|
global _LAST_APPSETTINGS_PATH
|
|
|
global _LAST_CONNECTION_STRING_REDACTED
|
|
|
|
|
|
paths = []
|
|
|
if getattr(sys, "frozen", False):
|
|
|
paths.append(os.path.join(os.path.dirname(sys.executable), "appsettings.json"))
|
|
|
paths.extend(("appsettings.json", os.path.join(os.path.dirname(__file__), "appsettings.json")))
|
|
|
for path in paths:
|
|
|
if os.path.isfile(path):
|
|
|
_LAST_APPSETTINGS_PATH = os.path.abspath(path)
|
|
|
with open(path, "r", encoding="utf-8") as f:
|
|
|
cfg = json.load(f)
|
|
|
cs = cfg.get("ConnectionStrings", {})
|
|
|
sql = cs.get("SqlServer", "")
|
|
|
if sql:
|
|
|
parts = {}
|
|
|
for part in sql.split(";"):
|
|
|
part = part.strip()
|
|
|
if not part or "=" not in part:
|
|
|
continue
|
|
|
k, v = part.split("=", 1)
|
|
|
parts[k.strip().lower()] = v.strip()
|
|
|
driver = "ODBC Driver 17 for SQL Server"
|
|
|
conn_str = (
|
|
|
f"DRIVER={{{driver}}};"
|
|
|
f"SERVER={parts.get('server', '')};"
|
|
|
f"DATABASE={parts.get('database', '')};"
|
|
|
f"UID={parts.get('user id', '')};"
|
|
|
f"PWD={parts.get('password', '')};"
|
|
|
+ ("TrustServerCertificate=yes;" if parts.get("trustservercertificate", "").lower() == "true" else "")
|
|
|
)
|
|
|
_LAST_CONNECTION_STRING_REDACTED = _redact_conn_str(conn_str)
|
|
|
return conn_str
|
|
|
|
|
|
if cs.get("Odbc"):
|
|
|
conn_str = cs["Odbc"]
|
|
|
_LAST_CONNECTION_STRING_REDACTED = _redact_conn_str(conn_str)
|
|
|
return conn_str
|
|
|
|
|
|
raise ValueError("В appsettings.json липсва ConnectionStrings:SqlServer или Odbc")
|
|
|
tried = [os.path.abspath(p) for p in paths]
|
|
|
raise FileNotFoundError("Не е намерен appsettings.json. Пробвани пътища:\n- " + "\n- ".join(tried))
|
|
|
|
|
|
|
|
|
def get_connection():
|
|
|
"""Отваря връзка към SQL Server (autocommit)."""
|
|
|
if pyodbc is None:
|
|
|
raise RuntimeError("Инсталирайте pyodbc: pip install pyodbc")
|
|
|
conn = pyodbc.connect(load_connection_string())
|
|
|
conn.autocommit = True
|
|
|
return conn
|
|
|
|
|
|
|
|
|
def _parse_iso(s):
|
|
|
if s is None:
|
|
|
return None
|
|
|
if hasattr(s, "isoformat"):
|
|
|
return s
|
|
|
try:
|
|
|
return datetime.fromisoformat(str(s).replace("Z", "+00:00"))
|
|
|
except Exception:
|
|
|
return None
|
|
|
|
|
|
|
|
|
def _utc_to_local(dt):
|
|
|
"""
|
|
|
Преобразува datetime от БД (съхранен като UTC чрез SYSUTCDATETIME()) в локално време за показване.
|
|
|
Така няма разминаване с 2 часа (UTC+2) при потребители в България.
|
|
|
"""
|
|
|
if dt is None:
|
|
|
return None
|
|
|
if hasattr(dt, "tzinfo") and dt.tzinfo is not None:
|
|
|
return dt.astimezone().replace(tzinfo=None)
|
|
|
# naive datetime от pyodbc = считаме за UTC
|
|
|
return dt.replace(tzinfo=timezone.utc).astimezone().replace(tzinfo=None)
|
|
|
|
|
|
|
|
|
def utc_to_local_for_display(dt):
|
|
|
"""Публична функция за показване на дата от БД в локално време (за main.py и др.)."""
|
|
|
return _utc_to_local(dt)
|
|
|
|
|
|
|
|
|
def _format_duration(minutes):
|
|
|
if minutes is None:
|
|
|
return ""
|
|
|
if minutes < 60:
|
|
|
return f"{int(minutes)}м"
|
|
|
h, m = divmod(int(minutes), 60)
|
|
|
return f"{h}ч {m}м"
|
|
|
|
|
|
|
|
|
def load_cycles(conn, limit=200):
|
|
|
"""
|
|
|
Зарежда последните цикли от ITD_Cycles.
|
|
|
Всеки ред = един цикъл с 5 полета за време (Post1At..Post5At) + ServiceClosed.
|
|
|
"""
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
SELECT y.Id, y.CardId, y.CycleNo, y.Post1At, y.Post2At, y.Post3At, y.Post4At, y.Post5At,
|
|
|
y.ServiceClosed, y.ServiceClosedAt,
|
|
|
c.Code, c.DisplayText, c.IsActive, c.UpdatedAt
|
|
|
FROM dbo.ITD_Cycles y
|
|
|
JOIN dbo.ITD_Cards c ON c.Id = y.CardId
|
|
|
ORDER BY y.Post1At DESC
|
|
|
"""
|
|
|
)
|
|
|
rows = cursor.fetchall()
|
|
|
|
|
|
result = []
|
|
|
for r in rows:
|
|
|
cycle_id = r.Id
|
|
|
card_id = r.CardId
|
|
|
t1 = _utc_to_local(_parse_iso(r.Post1At))
|
|
|
t2 = _utc_to_local(_parse_iso(r.Post2At))
|
|
|
t3 = _utc_to_local(_parse_iso(r.Post3At))
|
|
|
t4 = _utc_to_local(_parse_iso(r.Post4At))
|
|
|
t5 = _utc_to_local(_parse_iso(r.Post5At))
|
|
|
service_closed = bool(getattr(r, "ServiceClosed", False))
|
|
|
service_closed_at = getattr(r, "ServiceClosedAt", None)
|
|
|
manual_dt = _utc_to_local(_parse_iso(service_closed_at)) if service_closed_at else None
|
|
|
|
|
|
def _fmt_dt(dt):
|
|
|
return dt.strftime("%d.%m %H:%M") if dt else ""
|
|
|
|
|
|
post_times = {
|
|
|
1: _fmt_dt(t1),
|
|
|
2: _fmt_dt(t2),
|
|
|
3: _fmt_dt(t3),
|
|
|
4: _fmt_dt(t4),
|
|
|
5: _fmt_dt(t5),
|
|
|
}
|
|
|
|
|
|
post_durations = {1: "", 2: "", 3: "", 4: "", 5: ""}
|
|
|
if t1 and t2:
|
|
|
post_durations[1] = _format_duration((t2 - t1).total_seconds() / 60)
|
|
|
if t2 and t3:
|
|
|
post_durations[2] = _format_duration((t3 - t2).total_seconds() / 60)
|
|
|
if t3 and t4:
|
|
|
post_durations[3] = _format_duration((t4 - t3).total_seconds() / 60)
|
|
|
if t4 and t5:
|
|
|
post_durations[4] = _format_duration((t5 - t4).total_seconds() / 60)
|
|
|
|
|
|
reg_dt = t2 or t1
|
|
|
reg_str = reg_dt.strftime("%d.%m.%Y %H:%M") if reg_dt else ""
|
|
|
|
|
|
if t1 and t2:
|
|
|
time_reg_entry = _format_duration((t2 - t1).total_seconds() / 60)
|
|
|
else:
|
|
|
time_reg_entry = ""
|
|
|
|
|
|
parts = []
|
|
|
if t2 and t3:
|
|
|
parts.append(f"2→3: {_format_duration((t3 - t2).total_seconds() / 60)}")
|
|
|
if t3 and t4:
|
|
|
parts.append(f"3→4: {_format_duration((t4 - t3).total_seconds() / 60)}")
|
|
|
if t4 and t5:
|
|
|
parts.append(f"4→5: {_format_duration((t5 - t4).total_seconds() / 60)}")
|
|
|
time_between = " | ".join(parts) if parts else ""
|
|
|
|
|
|
exit_dt = t5 or manual_dt
|
|
|
service_exit = bool(service_closed and not t5)
|
|
|
if not exit_dt:
|
|
|
exit_str = ""
|
|
|
elif service_closed and not t5:
|
|
|
# Служебно затваряне – запазваме сегашния текст (дата/час)
|
|
|
exit_str = manual_dt.strftime("%d.%m.%Y %H:%M") if manual_dt else "Служебен изход"
|
|
|
if manual_dt:
|
|
|
exit_str = f"Служебен изход - {exit_str}"
|
|
|
else:
|
|
|
# Нормално напускане (има пост 5) – показваме общ престой от пост 1 до пост 5
|
|
|
if t1 and t5:
|
|
|
total_mins = (t5 - t1).total_seconds() / 60
|
|
|
exit_str = _format_duration(total_mins)
|
|
|
else:
|
|
|
exit_str = exit_dt.strftime("%d.%m.%Y %H:%M")
|
|
|
|
|
|
can_close = t5 is None and not service_closed
|
|
|
cycle_started_raw = r.Post1At
|
|
|
cycle_started_norm = _normalize_cycle_started_at(cycle_started_raw)
|
|
|
|
|
|
result.append(
|
|
|
{
|
|
|
"cycle_id": cycle_id,
|
|
|
"code": getattr(r, "Code", None) or "",
|
|
|
"display_text": r.DisplayText,
|
|
|
"reg_datetime": reg_str,
|
|
|
"time_reg_entry": time_reg_entry,
|
|
|
"time_between_posts": time_between,
|
|
|
"exit_datetime": exit_str,
|
|
|
"post1": f"{post_times[1]} {post_durations[1]}",
|
|
|
"post2": f"{post_times[2]} {post_durations[2]}",
|
|
|
"post3": f"{post_times[3]} {post_durations[3]}",
|
|
|
"post4": f"{post_times[4]} {post_durations[4]}",
|
|
|
"post5": f"{post_times[5]} {post_durations[5]}",
|
|
|
"service_exit": service_exit,
|
|
|
"can_close": can_close,
|
|
|
"card_id": card_id,
|
|
|
"is_active": bool(getattr(r, "IsActive", 1)),
|
|
|
"card_updated_at": getattr(r, "UpdatedAt", None),
|
|
|
"cycle_started_at": cycle_started_raw,
|
|
|
"cycle_started_at_normalized": cycle_started_norm,
|
|
|
}
|
|
|
)
|
|
|
|
|
|
return result[:limit]
|
|
|
|
|
|
|
|
|
def _normalize_cycle_started_at(cycle_started_at):
|
|
|
"""Нормализира датата за цикъл до naive UTC без микросекунди – един и същ ключ при запис, търсене и показване."""
|
|
|
if cycle_started_at is None:
|
|
|
return None
|
|
|
if hasattr(cycle_started_at, "year"):
|
|
|
dt = cycle_started_at
|
|
|
else:
|
|
|
dt = _parse_iso(cycle_started_at)
|
|
|
if dt is None:
|
|
|
return None
|
|
|
try:
|
|
|
if getattr(dt, "tzinfo", None):
|
|
|
dt = dt.astimezone(timezone.utc)
|
|
|
return dt.replace(microsecond=0, tzinfo=None)
|
|
|
except Exception:
|
|
|
try:
|
|
|
return dt.replace(microsecond=0, tzinfo=None)
|
|
|
except Exception:
|
|
|
return dt
|
|
|
|
|
|
|
|
|
def close_cycle_manually(conn, cycle_id):
|
|
|
"""Служебно затваряне на цикъл: маркира този цикъл в ITD_Cycles (ServiceClosed=1)."""
|
|
|
try:
|
|
|
cycle_id = int(cycle_id)
|
|
|
except (TypeError, ValueError):
|
|
|
raise ValueError("Невалиден идентификатор на цикъл.")
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
UPDATE dbo.ITD_Cycles
|
|
|
SET ServiceClosed = 1, ServiceClosedAt = SYSUTCDATETIME()
|
|
|
WHERE Id = ? AND ServiceClosed = 0
|
|
|
""",
|
|
|
(cycle_id,),
|
|
|
)
|
|
|
return cursor.rowcount > 0
|
|
|
|
|
|
|
|
|
def undo_manual_cycle_close(conn, cycle_id):
|
|
|
"""Отмяна на служебно затваряне: нулира ServiceClosed за този цикъл в ITD_Cycles."""
|
|
|
try:
|
|
|
cycle_id = int(cycle_id)
|
|
|
except (TypeError, ValueError):
|
|
|
raise ValueError("Невалиден идентификатор на цикъл.")
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
UPDATE dbo.ITD_Cycles
|
|
|
SET ServiceClosed = 0, ServiceClosedAt = NULL
|
|
|
WHERE Id = ?
|
|
|
""",
|
|
|
(cycle_id,),
|
|
|
)
|
|
|
return cursor.rowcount > 0
|
|
|
|
|
|
|
|
|
def get_card_by_code(conn, code):
|
|
|
"""Търси карта по Code (QR стойност). Връща None или dict с Id, Code, DisplayText, IsActive."""
|
|
|
if not code or not str(code).strip():
|
|
|
return None
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"SELECT Id, Code, DisplayText, IsActive FROM dbo.ITD_Cards WHERE Code = ? AND IsActive = 1",
|
|
|
(str(code).strip(),),
|
|
|
)
|
|
|
row = cursor.fetchone()
|
|
|
if not row:
|
|
|
return None
|
|
|
return {"id": row.Id, "code": row.Code, "display_text": row.DisplayText, "is_active": bool(row.IsActive)}
|
|
|
|
|
|
|
|
|
def add_registration(conn, card_id, post_index):
|
|
|
"""Добавя регистрация за карта на даден пост (1–5). Пост 1 = нов ред в ITD_Cycles; постове 2–5 = UPDATE на текущия цикъл."""
|
|
|
if post_index == 1 and has_open_cycle(conn, card_id):
|
|
|
raise ValueError("Вече сте влезли. Моля, излезте преди нова регистрация.")
|
|
|
cursor = conn.cursor()
|
|
|
if post_index == 1:
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
INSERT INTO dbo.ITD_Cycles (CardId, CycleNo, Post1At, Post2At, Post3At, Post4At, Post5At, ServiceClosed)
|
|
|
VALUES (?, (SELECT ISNULL(MAX(CycleNo), 0) + 1 FROM dbo.ITD_Cycles WHERE CardId = ?), SYSUTCDATETIME(), NULL, NULL, NULL, NULL, 0)
|
|
|
""",
|
|
|
(card_id, card_id),
|
|
|
)
|
|
|
else:
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
SELECT TOP 1 Id FROM dbo.ITD_Cycles
|
|
|
WHERE CardId = ? AND Post5At IS NULL AND ServiceClosed = 0
|
|
|
ORDER BY Post1At DESC
|
|
|
""",
|
|
|
(card_id,),
|
|
|
)
|
|
|
row = cursor.fetchone()
|
|
|
if not row:
|
|
|
raise ValueError("Няма отворен цикъл за тази карта.")
|
|
|
col = f"Post{post_index}At"
|
|
|
cursor.execute(f"UPDATE dbo.ITD_Cycles SET {col} = SYSUTCDATETIME() WHERE Id = ?", (row.Id,))
|
|
|
|
|
|
|
|
|
def set_card_active(conn, card_id, is_active):
|
|
|
"""Активира или деактивира карта. При деактивирана карта не може да се влиза (регистрира)."""
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"UPDATE dbo.ITD_Cards SET IsActive = ?, UpdatedAt = SYSUTCDATETIME() WHERE Id = ?",
|
|
|
(1 if is_active else 0, card_id),
|
|
|
)
|
|
|
|
|
|
|
|
|
def get_last_post_index(conn, card_id):
|
|
|
"""Връща последния попълнен пост (1–5) за дадена карта от последния цикъл, или None ако няма цикли."""
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
SELECT TOP 1 Post1At, Post2At, Post3At, Post4At, Post5At, ServiceClosed
|
|
|
FROM dbo.ITD_Cycles WHERE CardId = ? ORDER BY Post1At DESC
|
|
|
""",
|
|
|
(card_id,),
|
|
|
)
|
|
|
row = cursor.fetchone()
|
|
|
if not row:
|
|
|
return None
|
|
|
if row.Post5At or getattr(row, "ServiceClosed", False):
|
|
|
return 5
|
|
|
if row.Post4At:
|
|
|
return 4
|
|
|
if row.Post3At:
|
|
|
return 3
|
|
|
if row.Post2At:
|
|
|
return 2
|
|
|
return 1
|
|
|
|
|
|
|
|
|
def has_open_cycle(conn, card_id):
|
|
|
"""True ако картата има отворен цикъл (ред в ITD_Cycles с Post5At IS NULL и ServiceClosed = 0)."""
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
SELECT 1 FROM dbo.ITD_Cycles
|
|
|
WHERE CardId = ? AND Post5At IS NULL AND ServiceClosed = 0
|
|
|
""",
|
|
|
(card_id,),
|
|
|
)
|
|
|
return cursor.fetchone() is not None
|
|
|
|
|
|
|
|
|
def get_next_post_index(conn, card_id):
|
|
|
"""Връща следващия пост за регистрация (1–5). След служебно затваряне или пост 5 следва пост 1."""
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
SELECT TOP 1 Post2At, Post3At, Post4At, Post5At, ServiceClosed
|
|
|
FROM dbo.ITD_Cycles WHERE CardId = ? ORDER BY Post1At DESC
|
|
|
""",
|
|
|
(card_id,),
|
|
|
)
|
|
|
row = cursor.fetchone()
|
|
|
if not row:
|
|
|
return 1
|
|
|
if getattr(row, "ServiceClosed", False) or row.Post5At:
|
|
|
return 1
|
|
|
if not row.Post2At:
|
|
|
return 2
|
|
|
if not row.Post3At:
|
|
|
return 3
|
|
|
if not row.Post4At:
|
|
|
return 4
|
|
|
return 5
|
|
|
|
|
|
|
|
|
def load_cards(conn):
|
|
|
"""Връща списък с всички карти за административния модул."""
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
SELECT Id, Code, DisplayText, IsActive, CreatedAt, UpdatedAt
|
|
|
FROM dbo.ITD_Cards
|
|
|
ORDER BY DisplayText
|
|
|
"""
|
|
|
)
|
|
|
rows = cursor.fetchall()
|
|
|
result = []
|
|
|
for r in rows:
|
|
|
result.append(
|
|
|
{
|
|
|
"id": r.Id,
|
|
|
"code": r.Code,
|
|
|
"display_text": r.DisplayText,
|
|
|
"is_active": bool(r.IsActive),
|
|
|
"created_at": r.CreatedAt,
|
|
|
"updated_at": r.UpdatedAt,
|
|
|
}
|
|
|
)
|
|
|
return result
|
|
|
|
|
|
|
|
|
def delete_parking_only_cycles_for_card(conn, card_code):
|
|
|
"""
|
|
|
Изтрива всички цикли „само паркинг“ (само Post1At е попълнен) за карта с даден Code.
|
|
|
Връща (брой изтрити цикли, 0) за съвместимост със стария API.
|
|
|
"""
|
|
|
card_code = str(card_code).strip()
|
|
|
if not card_code:
|
|
|
raise ValueError("Кодът на картата е задължителен.")
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute("SELECT Id FROM dbo.ITD_Cards WHERE Code = ?", (card_code,))
|
|
|
row = cursor.fetchone()
|
|
|
if not row:
|
|
|
return (0, 0)
|
|
|
card_id = int(row.Id)
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
DELETE FROM dbo.ITD_Cycles
|
|
|
WHERE CardId = ? AND Post2At IS NULL AND Post3At IS NULL AND Post4At IS NULL AND Post5At IS NULL
|
|
|
""",
|
|
|
(card_id,),
|
|
|
)
|
|
|
return (cursor.rowcount, 0)
|
|
|
|
|
|
|
|
|
def create_card(conn, display_text, is_active=True):
|
|
|
"""Създава нова карта. Кодът се задава служебно равен на Id. Връща Id на картата."""
|
|
|
display_text = str(display_text).strip()
|
|
|
if not display_text:
|
|
|
raise ValueError("Текстът на картата е задължителен.")
|
|
|
cursor = conn.cursor()
|
|
|
# Временен уникален код (NEWID), след което Code се обновява на Id
|
|
|
cursor.execute(
|
|
|
"""
|
|
|
INSERT INTO dbo.ITD_Cards (Code, DisplayText, IsActive)
|
|
|
OUTPUT INSERTED.Id
|
|
|
VALUES (CONVERT(NVARCHAR(36), NEWID()), ?, ?)
|
|
|
""",
|
|
|
(display_text, 1 if is_active else 0),
|
|
|
)
|
|
|
row = cursor.fetchone()
|
|
|
new_id = row[0] if row else None
|
|
|
if new_id is None:
|
|
|
raise RuntimeError("Картата е записана, но не може да се прочете новото Id.")
|
|
|
new_id = int(new_id)
|
|
|
cursor.execute("UPDATE dbo.ITD_Cards SET Code = ? WHERE Id = ?", (str(new_id), new_id))
|
|
|
return new_id
|
|
|
|
|
|
|
|
|
def update_card(conn, card_id, display_text):
|
|
|
"""Обновява текста на карта (DisplayText). Кодът не се променя."""
|
|
|
display_text = str(display_text).strip()
|
|
|
if not display_text:
|
|
|
raise ValueError("Текстът на картата е задължителен.")
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute(
|
|
|
"UPDATE dbo.ITD_Cards SET DisplayText = ?, UpdatedAt = SYSUTCDATETIME() WHERE Id = ?",
|
|
|
(display_text, card_id),
|
|
|
)
|
|
|
if cursor.rowcount == 0:
|
|
|
raise ValueError("Картата не е намерена.")
|
|
|
|
|
|
|
|
|
def delete_card(conn, card_id):
|
|
|
"""Изтрива карта и всички нейни цикли (ITD_Cycles)."""
|
|
|
card_id = int(card_id)
|
|
|
cursor = conn.cursor()
|
|
|
cursor.execute("DELETE FROM dbo.ITD_Cycles WHERE CardId = ?", (card_id,))
|
|
|
cursor.execute("DELETE FROM dbo.ITD_Cards WHERE Id = ?", (card_id,))
|
|
|
if cursor.rowcount == 0:
|
|
|
raise ValueError("Картата не е намерена.")
|
|
|
|