331 lines
12 KiB
Python
331 lines
12 KiB
Python
"""
|
|
legacy_attendance_service.py
|
|
=============================
|
|
Read-only data access for the "Legacy Attendance" feature.
|
|
|
|
This talks directly to the OLD remote MySQL server (the one described by
|
|
QrCodeLtServices.sql: `contract`, `employee`, `locations`, `records` tables)
|
|
using pymysql — never SQLAlchemy ORM — because that schema is completely
|
|
different from the current app's models and is not, and should never be,
|
|
mapped as a SQLAlchemy model.
|
|
|
|
Connection is opened per-call and closed immediately after use (no pooling,
|
|
no persistent connection kept on `g` or the app) because this data is only
|
|
ever displayed, never written to. Nothing here performs INSERT/UPDATE/DELETE
|
|
against the remote server.
|
|
|
|
Env vars (already used by employee_table_sync.py):
|
|
REMOTE_DB_HOST
|
|
REMOTE_DB_PORT
|
|
REMOTE_DB_USERNAME
|
|
REMOTE_DB_PASSWORD
|
|
REMOTE_DB_NAME
|
|
"""
|
|
|
|
import io
|
|
import math
|
|
from datetime import datetime, timedelta
|
|
|
|
import pymysql
|
|
import pymysql.cursors
|
|
|
|
from config import Config
|
|
from utils.excel_safety import neutralize_unexpected_formulas
|
|
|
|
try:
|
|
import openpyxl
|
|
from openpyxl.styles import Font, PatternFill, Alignment
|
|
from openpyxl.utils import get_column_letter
|
|
except ImportError: # pragma: no cover — openpyxl is already a hard requirement elsewhere
|
|
openpyxl = None
|
|
|
|
|
|
class LegacyDbUnavailable(Exception):
|
|
"""Raised when the remote legacy database cannot be reached or is not configured."""
|
|
pass
|
|
|
|
|
|
def get_remote_connection():
|
|
"""
|
|
Open a fresh, read-only connection to the legacy remote MySQL server.
|
|
Caller is responsible for closing it (use as a context manager).
|
|
"""
|
|
if not Config.REMOTE_DB_HOST or not Config.REMOTE_DB_NAME:
|
|
raise LegacyDbUnavailable(
|
|
"Legacy database is not configured. Set REMOTE_DB_HOST, REMOTE_DB_PORT, "
|
|
"REMOTE_DB_USERNAME, REMOTE_DB_PASSWORD, REMOTE_DB_NAME in .env"
|
|
)
|
|
try:
|
|
return pymysql.connect(
|
|
host=Config.REMOTE_DB_HOST,
|
|
port=Config.REMOTE_DB_PORT,
|
|
user=Config.REMOTE_DB_USERNAME,
|
|
password=Config.REMOTE_DB_PASSWORD,
|
|
database=Config.REMOTE_DB_NAME,
|
|
charset='utf8mb4',
|
|
cursorclass=pymysql.cursors.DictCursor,
|
|
connect_timeout=10,
|
|
read_timeout=30,
|
|
)
|
|
except pymysql.MySQLError as e:
|
|
raise LegacyDbUnavailable(f"Could not connect to legacy database: {e}")
|
|
|
|
|
|
class LegacyPagination:
|
|
"""
|
|
Minimal stand-in for Flask-SQLAlchemy's Pagination object, so templates
|
|
can use the same `.items / .page / .pages / .has_prev / .iter_pages()`
|
|
pattern already used by time_attendance_records.html.
|
|
"""
|
|
|
|
def __init__(self, items, page, per_page, total):
|
|
self.items = items
|
|
self.page = page
|
|
self.per_page = per_page
|
|
self.total = total
|
|
self.pages = max(1, math.ceil(total / per_page)) if per_page else 1
|
|
|
|
@property
|
|
def has_prev(self):
|
|
return self.page > 1
|
|
|
|
@property
|
|
def has_next(self):
|
|
return self.page < self.pages
|
|
|
|
@property
|
|
def prev_num(self):
|
|
return self.page - 1
|
|
|
|
@property
|
|
def next_num(self):
|
|
return self.page + 1
|
|
|
|
def iter_pages(self, left_edge=1, right_edge=1, left_current=1, right_current=2):
|
|
last = 0
|
|
for num in range(1, self.pages + 1):
|
|
if (num <= left_edge
|
|
or (num > self.page - left_current - 1 and num < self.page + right_current)
|
|
or num > self.pages - right_edge):
|
|
if last + 1 != num:
|
|
yield None
|
|
yield num
|
|
last = num
|
|
|
|
|
|
# ---------------------------------------------------------------------- #
|
|
# Shared filter -> WHERE clause builder
|
|
# ---------------------------------------------------------------------- #
|
|
def _build_where(filters):
|
|
"""
|
|
Build a WHERE clause + params list shared by count/list/export queries.
|
|
filters: dict with optional keys: employee_search, location, record_type,
|
|
start_date, end_date (all strings; dates as 'YYYY-MM-DD')
|
|
"""
|
|
clauses = []
|
|
params = []
|
|
|
|
employee_search = (filters.get('employee_search') or '').strip()
|
|
if employee_search:
|
|
clauses.append(
|
|
"(r.employeeId LIKE %s OR CONCAT(e.firstName, ' ', e.lastName) LIKE %s)"
|
|
)
|
|
like = f"%{employee_search}%"
|
|
params.extend([like, like])
|
|
|
|
location = (filters.get('location') or '').strip()
|
|
if location:
|
|
clauses.append("l.location = %s")
|
|
params.append(location)
|
|
|
|
record_type = (filters.get('record_type') or '').strip()
|
|
if record_type:
|
|
clauses.append("r.type = %s")
|
|
params.append(record_type)
|
|
|
|
start_date = (filters.get('start_date') or '').strip()
|
|
if start_date:
|
|
try:
|
|
start_dt = datetime.strptime(start_date, '%Y-%m-%d')
|
|
clauses.append("r.time >= %s")
|
|
params.append(start_dt)
|
|
except ValueError:
|
|
pass
|
|
|
|
end_date = (filters.get('end_date') or '').strip()
|
|
if end_date:
|
|
try:
|
|
end_dt = datetime.strptime(end_date, '%Y-%m-%d') + timedelta(days=1)
|
|
clauses.append("r.time < %s")
|
|
params.append(end_dt)
|
|
except ValueError:
|
|
pass
|
|
|
|
where_sql = (" WHERE " + " AND ".join(clauses)) if clauses else ""
|
|
return where_sql, params
|
|
|
|
|
|
_BASE_FROM = """
|
|
FROM records r
|
|
LEFT JOIN employee e ON e.id = CAST(r.employeeId AS UNSIGNED)
|
|
LEFT JOIN locations l ON l.`index` = CAST(r.locationId AS UNSIGNED)
|
|
LEFT JOIN contract c ON c.id = r.contractId
|
|
"""
|
|
|
|
_SELECT_COLUMNS = """
|
|
r.`index` AS record_index,
|
|
r.employeeId AS employee_id,
|
|
r.time AS record_time,
|
|
r.type AS record_type,
|
|
r.recordedAddress AS recorded_address,
|
|
r.locationId AS location_id_raw,
|
|
r.jobCode AS job_code,
|
|
r.isManual AS is_manual,
|
|
r.contractId AS contract_id,
|
|
e.firstName AS first_name,
|
|
e.lastName AS last_name,
|
|
l.location AS location_name,
|
|
l.building AS building,
|
|
l.address AS location_address,
|
|
c.name AS contract_name,
|
|
c.company AS contract_company
|
|
"""
|
|
|
|
|
|
def get_legacy_dashboard_stats():
|
|
"""Summary stats for the Legacy Attendance dashboard."""
|
|
stats = {
|
|
'total_records': 0,
|
|
'unique_employees': 0,
|
|
'unique_locations': 0,
|
|
'earliest_record': None,
|
|
'latest_record': None,
|
|
}
|
|
with get_remote_connection() as conn:
|
|
with conn.cursor() as cur:
|
|
cur.execute("""
|
|
SELECT
|
|
COUNT(*) AS total_records,
|
|
COUNT(DISTINCT employeeId) AS unique_employees,
|
|
COUNT(DISTINCT locationId) AS unique_locations,
|
|
MIN(time) AS earliest_record,
|
|
MAX(time) AS latest_record
|
|
FROM records
|
|
""")
|
|
row = cur.fetchone()
|
|
if row:
|
|
stats.update(row)
|
|
return stats
|
|
|
|
|
|
def get_legacy_unique_locations():
|
|
"""Distinct location names for the records filter dropdown."""
|
|
with get_remote_connection() as conn:
|
|
with conn.cursor() as cur:
|
|
cur.execute("""
|
|
SELECT DISTINCT location FROM locations
|
|
WHERE location IS NOT NULL AND location != ''
|
|
ORDER BY location
|
|
""")
|
|
return [row['location'] for row in cur.fetchall()]
|
|
|
|
|
|
def get_legacy_records(filters, page=1, per_page=50):
|
|
"""
|
|
Fetch a filtered, paginated page of legacy attendance records, joined
|
|
against employee/locations/contract for display.
|
|
Returns a LegacyPagination instance.
|
|
"""
|
|
where_sql, params = _build_where(filters)
|
|
|
|
with get_remote_connection() as conn:
|
|
with conn.cursor() as cur:
|
|
cur.execute(f"SELECT COUNT(*) AS total {_BASE_FROM}{where_sql}", params)
|
|
total = cur.fetchone()['total']
|
|
|
|
offset = max(0, (page - 1) * per_page)
|
|
cur.execute(
|
|
f"SELECT {_SELECT_COLUMNS} {_BASE_FROM}{where_sql} "
|
|
f"ORDER BY r.time DESC LIMIT %s OFFSET %s",
|
|
params + [per_page, offset]
|
|
)
|
|
rows = cur.fetchall()
|
|
|
|
for row in rows:
|
|
first = (row.get('first_name') or '').strip()
|
|
last = (row.get('last_name') or '').strip()
|
|
row['resolved_employee_name'] = f"{last}, {first}" if (first or last) else 'Unknown'
|
|
row['location_display'] = row.get('location_name') or row.get('location_id_raw') or 'Unknown'
|
|
|
|
return LegacyPagination(rows, page, per_page, total)
|
|
|
|
|
|
def get_legacy_records_for_export(filters, max_rows=50000):
|
|
"""Fetch ALL matching rows (no pagination) for Excel export."""
|
|
where_sql, params = _build_where(filters)
|
|
with get_remote_connection() as conn:
|
|
with conn.cursor() as cur:
|
|
cur.execute(
|
|
f"SELECT {_SELECT_COLUMNS} {_BASE_FROM}{where_sql} "
|
|
f"ORDER BY r.time DESC LIMIT %s",
|
|
params + [max_rows]
|
|
)
|
|
rows = cur.fetchall()
|
|
|
|
for row in rows:
|
|
first = (row.get('first_name') or '').strip()
|
|
last = (row.get('last_name') or '').strip()
|
|
row['resolved_employee_name'] = f"{last}, {first}" if (first or last) else 'Unknown'
|
|
row['location_display'] = row.get('location_name') or row.get('location_id_raw') or 'Unknown'
|
|
|
|
return rows
|
|
|
|
|
|
def build_legacy_export_workbook(rows):
|
|
"""Build an openpyxl Workbook (in-memory) for the given legacy records."""
|
|
wb = openpyxl.Workbook()
|
|
ws = wb.active
|
|
ws.title = "Legacy Attendance"
|
|
|
|
headers = [
|
|
'Employee ID', 'Employee Name', 'Date', 'Time', 'Type',
|
|
'Location', 'Building', 'Location Address', 'Recorded Address',
|
|
'Contract', 'Company', 'Job Code', 'Manual Entry'
|
|
]
|
|
header_fill = PatternFill(start_color='1F2937', end_color='1F2937', fill_type='solid')
|
|
header_font = Font(color='FFFFFF', bold=True)
|
|
for col_idx, header in enumerate(headers, start=1):
|
|
cell = ws.cell(row=1, column=col_idx, value=header)
|
|
cell.fill = header_fill
|
|
cell.font = header_font
|
|
cell.alignment = Alignment(horizontal='center', vertical='center')
|
|
|
|
for row_idx, row in enumerate(rows, start=2):
|
|
record_time = row.get('record_time')
|
|
date_str = record_time.strftime('%Y-%m-%d') if record_time else ''
|
|
time_str = record_time.strftime('%H:%M:%S') if record_time else ''
|
|
ws.cell(row=row_idx, column=1, value=row.get('employee_id'))
|
|
ws.cell(row=row_idx, column=2, value=row.get('resolved_employee_name'))
|
|
ws.cell(row=row_idx, column=3, value=date_str)
|
|
ws.cell(row=row_idx, column=4, value=time_str)
|
|
ws.cell(row=row_idx, column=5, value=row.get('record_type'))
|
|
ws.cell(row=row_idx, column=6, value=row.get('location_display'))
|
|
ws.cell(row=row_idx, column=7, value=row.get('building'))
|
|
ws.cell(row=row_idx, column=8, value=row.get('location_address'))
|
|
ws.cell(row=row_idx, column=9, value=row.get('recorded_address'))
|
|
ws.cell(row=row_idx, column=10, value=row.get('contract_name'))
|
|
ws.cell(row=row_idx, column=11, value=row.get('contract_company'))
|
|
ws.cell(row=row_idx, column=12, value=row.get('job_code'))
|
|
ws.cell(row=row_idx, column=13, value='Yes' if row.get('is_manual') else 'No')
|
|
|
|
for col_idx in range(1, len(headers) + 1):
|
|
ws.column_dimensions[get_column_letter(col_idx)].width = 20
|
|
|
|
ws.freeze_panes = 'A2'
|
|
|
|
buffer = io.BytesIO()
|
|
neutralize_unexpected_formulas(wb) # formula-injection guard (utils/excel_safety.py)
|
|
wb.save(buffer)
|
|
buffer.seek(0)
|
|
return buffer
|