feat: KKS P240/P241 蓝牙工牌管理系统初始提交
FastAPI + SQLAlchemy + asyncio TCP 服务器，支持设备管理、实时定位、 告警、考勤打卡、蓝牙记录、指令下发、TTS语音播报等功能。
This commit is contained in:
0
app/services/__init__.py
Normal file
0
app/services/__init__.py
Normal file
94
app/services/beacon_service.py
Normal file
94
app/services/beacon_service.py
Normal file
@@ -0,0 +1,94 @@
|
||||
"""
|
||||
Beacon Service - 蓝牙信标管理服务
|
||||
Provides CRUD operations for Bluetooth beacon configuration.
|
||||
"""
|
||||
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from sqlalchemy import func, select, or_
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models import BeaconConfig
|
||||
from app.schemas import BeaconConfigCreate, BeaconConfigUpdate
|
||||
|
||||
|
||||
async def get_beacons(
|
||||
db: AsyncSession,
|
||||
page: int = 1,
|
||||
page_size: int = 20,
|
||||
status_filter: str | None = None,
|
||||
search: str | None = None,
|
||||
) -> tuple[list[BeaconConfig], int]:
|
||||
"""Get paginated beacon list with optional filters."""
|
||||
query = select(BeaconConfig)
|
||||
count_query = select(func.count(BeaconConfig.id))
|
||||
|
||||
if status_filter:
|
||||
query = query.where(BeaconConfig.status == status_filter)
|
||||
count_query = count_query.where(BeaconConfig.status == status_filter)
|
||||
|
||||
if search:
|
||||
like = f"%{search}%"
|
||||
cond = or_(
|
||||
BeaconConfig.beacon_mac.ilike(like),
|
||||
BeaconConfig.name.ilike(like),
|
||||
BeaconConfig.area.ilike(like),
|
||||
)
|
||||
query = query.where(cond)
|
||||
count_query = count_query.where(cond)
|
||||
|
||||
total_result = await db.execute(count_query)
|
||||
total = total_result.scalar() or 0
|
||||
|
||||
offset = (page - 1) * page_size
|
||||
query = query.order_by(BeaconConfig.created_at.desc()).offset(offset).limit(page_size)
|
||||
result = await db.execute(query)
|
||||
return list(result.scalars().all()), total
|
||||
|
||||
|
||||
async def get_beacon(db: AsyncSession, beacon_id: int) -> BeaconConfig | None:
|
||||
result = await db.execute(
|
||||
select(BeaconConfig).where(BeaconConfig.id == beacon_id)
|
||||
)
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
|
||||
async def get_beacon_by_mac(db: AsyncSession, mac: str) -> BeaconConfig | None:
|
||||
result = await db.execute(
|
||||
select(BeaconConfig).where(BeaconConfig.beacon_mac == mac)
|
||||
)
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
|
||||
async def create_beacon(db: AsyncSession, data: BeaconConfigCreate) -> BeaconConfig:
|
||||
beacon = BeaconConfig(**data.model_dump())
|
||||
db.add(beacon)
|
||||
await db.flush()
|
||||
await db.refresh(beacon)
|
||||
return beacon
|
||||
|
||||
|
||||
async def update_beacon(
|
||||
db: AsyncSession, beacon_id: int, data: BeaconConfigUpdate
|
||||
) -> BeaconConfig | None:
|
||||
beacon = await get_beacon(db, beacon_id)
|
||||
if beacon is None:
|
||||
return None
|
||||
|
||||
update_data = data.model_dump(exclude_unset=True)
|
||||
for key, value in update_data.items():
|
||||
setattr(beacon, key, value)
|
||||
beacon.updated_at = datetime.now(timezone.utc)
|
||||
|
||||
await db.flush()
|
||||
await db.refresh(beacon)
|
||||
return beacon
|
||||
|
||||
|
||||
async def delete_beacon(db: AsyncSession, beacon_id: int) -> bool:
|
||||
beacon = await get_beacon(db, beacon_id)
|
||||
if beacon is None:
|
||||
return False
|
||||
await db.delete(beacon)
|
||||
await db.flush()
|
||||
return True
|
||||
110
app/services/command_service.py
Normal file
110
app/services/command_service.py
Normal file
@@ -0,0 +1,110 @@
|
||||
"""
|
||||
Command Service - 指令管理服务
|
||||
Provides CRUD operations for device command logs.
|
||||
"""
|
||||
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models import CommandLog
|
||||
|
||||
|
||||
async def get_commands(
|
||||
db: AsyncSession,
|
||||
device_id: int | None = None,
|
||||
command_type: str | None = None,
|
||||
status: str | None = None,
|
||||
page: int = 1,
|
||||
page_size: int = 20,
|
||||
) -> tuple[list[CommandLog], int]:
|
||||
"""
|
||||
获取指令列表（分页）/ Get paginated command logs.
|
||||
"""
|
||||
query = select(CommandLog)
|
||||
count_query = select(func.count(CommandLog.id))
|
||||
|
||||
if device_id is not None:
|
||||
query = query.where(CommandLog.device_id == device_id)
|
||||
count_query = count_query.where(CommandLog.device_id == device_id)
|
||||
|
||||
if command_type:
|
||||
query = query.where(CommandLog.command_type == command_type)
|
||||
count_query = count_query.where(CommandLog.command_type == command_type)
|
||||
|
||||
if status:
|
||||
query = query.where(CommandLog.status == status)
|
||||
count_query = count_query.where(CommandLog.status == status)
|
||||
|
||||
total_result = await db.execute(count_query)
|
||||
total = total_result.scalar() or 0
|
||||
|
||||
offset = (page - 1) * page_size
|
||||
query = query.order_by(CommandLog.created_at.desc()).offset(offset).limit(page_size)
|
||||
result = await db.execute(query)
|
||||
commands = list(result.scalars().all())
|
||||
|
||||
return commands, total
|
||||
|
||||
|
||||
async def create_command(
|
||||
db: AsyncSession,
|
||||
device_id: int,
|
||||
command_type: str,
|
||||
command_content: str,
|
||||
server_flag: str = "badge_admin",
|
||||
) -> CommandLog:
|
||||
"""
|
||||
创建指令记录 / Create a new command log entry.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
device_id : int
|
||||
Target device ID.
|
||||
command_type : str
|
||||
Type of command.
|
||||
command_content : str
|
||||
Command payload content.
|
||||
server_flag : str
|
||||
Server flag identifier.
|
||||
|
||||
Returns
|
||||
-------
|
||||
CommandLog
|
||||
The newly created command log.
|
||||
"""
|
||||
command = CommandLog(
|
||||
device_id=device_id,
|
||||
command_type=command_type,
|
||||
command_content=command_content,
|
||||
server_flag=server_flag,
|
||||
status="pending",
|
||||
)
|
||||
db.add(command)
|
||||
await db.flush()
|
||||
await db.refresh(command)
|
||||
return command
|
||||
|
||||
|
||||
async def get_command(db: AsyncSession, command_id: int) -> CommandLog | None:
|
||||
"""
|
||||
按ID获取指令 / Get command log by ID.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
command_id : int
|
||||
Command log primary key.
|
||||
|
||||
Returns
|
||||
-------
|
||||
CommandLog | None
|
||||
"""
|
||||
result = await db.execute(
|
||||
select(CommandLog).where(CommandLog.id == command_id)
|
||||
)
|
||||
return result.scalar_one_or_none()
|
||||
312
app/services/device_service.py
Normal file
312
app/services/device_service.py
Normal file
@@ -0,0 +1,312 @@
|
||||
"""
|
||||
Device Service - 设备管理服务
|
||||
Provides CRUD operations and statistics for badge devices.
|
||||
"""
|
||||
|
||||
from datetime import datetime, timezone
|
||||
|
||||
from sqlalchemy import func, select, or_
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models import Device
|
||||
from app.schemas import DeviceCreate, DeviceUpdate, BatchDeviceCreateItem
|
||||
|
||||
|
||||
async def get_devices(
|
||||
db: AsyncSession,
|
||||
page: int = 1,
|
||||
page_size: int = 20,
|
||||
status_filter: str | None = None,
|
||||
search: str | None = None,
|
||||
) -> tuple[list[Device], int]:
|
||||
"""
|
||||
获取设备列表（分页）/ Get paginated device list.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
page : int
|
||||
Page number (1-indexed).
|
||||
page_size : int
|
||||
Number of items per page.
|
||||
status_filter : str, optional
|
||||
Filter by device status (online / offline).
|
||||
search : str, optional
|
||||
Search by IMEI or device name.
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple[list[Device], int]
|
||||
(list of devices, total count)
|
||||
"""
|
||||
query = select(Device)
|
||||
count_query = select(func.count(Device.id))
|
||||
|
||||
if status_filter:
|
||||
query = query.where(Device.status == status_filter)
|
||||
count_query = count_query.where(Device.status == status_filter)
|
||||
|
||||
if search:
|
||||
pattern = f"%{search}%"
|
||||
search_clause = or_(
|
||||
Device.imei.ilike(pattern),
|
||||
Device.name.ilike(pattern),
|
||||
)
|
||||
query = query.where(search_clause)
|
||||
count_query = count_query.where(search_clause)
|
||||
|
||||
# Total count
|
||||
total_result = await db.execute(count_query)
|
||||
total = total_result.scalar() or 0
|
||||
|
||||
# Paginated results
|
||||
offset = (page - 1) * page_size
|
||||
query = query.order_by(Device.updated_at.desc()).offset(offset).limit(page_size)
|
||||
result = await db.execute(query)
|
||||
devices = list(result.scalars().all())
|
||||
|
||||
return devices, total
|
||||
|
||||
|
||||
async def get_device(db: AsyncSession, device_id: int) -> Device | None:
|
||||
"""
|
||||
按ID获取设备 / Get device by ID.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
device_id : int
|
||||
Device primary key.
|
||||
|
||||
Returns
|
||||
-------
|
||||
Device | None
|
||||
"""
|
||||
result = await db.execute(select(Device).where(Device.id == device_id))
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
|
||||
async def get_device_by_imei(db: AsyncSession, imei: str) -> Device | None:
|
||||
"""
|
||||
按IMEI获取设备 / Get device by IMEI number.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
imei : str
|
||||
Device IMEI number.
|
||||
|
||||
Returns
|
||||
-------
|
||||
Device | None
|
||||
"""
|
||||
result = await db.execute(select(Device).where(Device.imei == imei))
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
|
||||
async def create_device(db: AsyncSession, device_data: DeviceCreate) -> Device:
|
||||
"""
|
||||
创建设备 / Create a new device.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
device_data : DeviceCreate
|
||||
Device creation data.
|
||||
|
||||
Returns
|
||||
-------
|
||||
Device
|
||||
The newly created device.
|
||||
"""
|
||||
device = Device(**device_data.model_dump())
|
||||
db.add(device)
|
||||
await db.flush()
|
||||
await db.refresh(device)
|
||||
return device
|
||||
|
||||
|
||||
async def update_device(
|
||||
db: AsyncSession, device_id: int, device_data: DeviceUpdate
|
||||
) -> Device | None:
|
||||
"""
|
||||
更新设备信息 / Update device information.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
device_id : int
|
||||
Device primary key.
|
||||
device_data : DeviceUpdate
|
||||
Fields to update (only non-None fields are applied).
|
||||
|
||||
Returns
|
||||
-------
|
||||
Device | None
|
||||
The updated device, or None if not found.
|
||||
"""
|
||||
device = await get_device(db, device_id)
|
||||
if device is None:
|
||||
return None
|
||||
|
||||
update_fields = device_data.model_dump(exclude_unset=True)
|
||||
for field, value in update_fields.items():
|
||||
setattr(device, field, value)
|
||||
|
||||
device.updated_at = datetime.now(timezone.utc)
|
||||
await db.flush()
|
||||
await db.refresh(device)
|
||||
return device
|
||||
|
||||
|
||||
async def delete_device(db: AsyncSession, device_id: int) -> bool:
|
||||
"""
|
||||
删除设备 / Delete a device.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
device_id : int
|
||||
Device primary key.
|
||||
|
||||
Returns
|
||||
-------
|
||||
bool
|
||||
True if the device was deleted, False if not found.
|
||||
"""
|
||||
device = await get_device(db, device_id)
|
||||
if device is None:
|
||||
return False
|
||||
|
||||
await db.delete(device)
|
||||
await db.flush()
|
||||
return True
|
||||
|
||||
|
||||
async def get_devices_by_ids(db: AsyncSession, device_ids: list[int]) -> list[Device]:
|
||||
"""Fetch multiple devices by IDs in a single query."""
|
||||
if not device_ids:
|
||||
return []
|
||||
result = await db.execute(select(Device).where(Device.id.in_(device_ids)))
|
||||
return list(result.scalars().all())
|
||||
|
||||
|
||||
async def get_devices_by_imeis(db: AsyncSession, imeis: list[str]) -> list[Device]:
|
||||
"""Fetch multiple devices by IMEIs in a single query."""
|
||||
if not imeis:
|
||||
return []
|
||||
result = await db.execute(select(Device).where(Device.imei.in_(imeis)))
|
||||
return list(result.scalars().all())
|
||||
|
||||
|
||||
async def batch_create_devices(
|
||||
db: AsyncSession, items: list[BatchDeviceCreateItem]
|
||||
) -> list[dict]:
|
||||
"""Batch create devices, skipping duplicates. Uses single query to check existing."""
|
||||
# One query to find all existing IMEIs
|
||||
imeis = [item.imei for item in items]
|
||||
existing_devices = await get_devices_by_imeis(db, imeis)
|
||||
existing_imeis = {d.imei for d in existing_devices}
|
||||
|
||||
results: list[dict] = [{} for _ in range(len(items))] # preserve input order
|
||||
new_device_indices: list[tuple[int, Device]] = []
|
||||
seen_imeis: set[str] = set()
|
||||
for i, item in enumerate(items):
|
||||
if item.imei in existing_imeis:
|
||||
results[i] = {"imei": item.imei, "success": False, "device_id": None, "error": f"IMEI {item.imei} already exists"}
|
||||
continue
|
||||
if item.imei in seen_imeis:
|
||||
results[i] = {"imei": item.imei, "success": False, "device_id": None, "error": "Duplicate IMEI in request"}
|
||||
continue
|
||||
seen_imeis.add(item.imei)
|
||||
device = Device(imei=item.imei, device_type=item.device_type, name=item.name)
|
||||
db.add(device)
|
||||
new_device_indices.append((i, device))
|
||||
|
||||
if new_device_indices:
|
||||
await db.flush()
|
||||
for idx, device in new_device_indices:
|
||||
await db.refresh(device)
|
||||
results[idx] = {"imei": device.imei, "success": True, "device_id": device.id, "error": None}
|
||||
|
||||
return results
|
||||
|
||||
|
||||
async def batch_update_devices(
|
||||
db: AsyncSession, device_ids: list[int], update_data: DeviceUpdate
|
||||
) -> list[dict]:
|
||||
"""Batch update devices with the same settings. Uses single query to fetch all."""
|
||||
devices = await get_devices_by_ids(db, device_ids)
|
||||
found_map = {d.id: d for d in devices}
|
||||
update_fields = update_data.model_dump(exclude_unset=True)
|
||||
now = datetime.now(timezone.utc)
|
||||
|
||||
results = []
|
||||
for device_id in device_ids:
|
||||
device = found_map.get(device_id)
|
||||
if device is None:
|
||||
results.append({"device_id": device_id, "success": False, "error": f"Device {device_id} not found"})
|
||||
continue
|
||||
for field, value in update_fields.items():
|
||||
setattr(device, field, value)
|
||||
device.updated_at = now
|
||||
results.append({"device_id": device_id, "success": True, "error": None})
|
||||
|
||||
if any(r["success"] for r in results):
|
||||
await db.flush()
|
||||
|
||||
return results
|
||||
|
||||
|
||||
async def batch_delete_devices(
|
||||
db: AsyncSession, device_ids: list[int]
|
||||
) -> list[dict]:
|
||||
"""Batch delete devices. Uses single query to fetch all."""
|
||||
devices = await get_devices_by_ids(db, device_ids)
|
||||
found_map = {d.id: d for d in devices}
|
||||
|
||||
results = []
|
||||
for device_id in device_ids:
|
||||
device = found_map.get(device_id)
|
||||
if device is None:
|
||||
results.append({"device_id": device_id, "success": False, "error": f"Device {device_id} not found"})
|
||||
continue
|
||||
await db.delete(device)
|
||||
results.append({"device_id": device_id, "success": True, "error": None})
|
||||
|
||||
if any(r["success"] for r in results):
|
||||
await db.flush()
|
||||
|
||||
return results
|
||||
|
||||
|
||||
async def get_device_stats(db: AsyncSession) -> dict:
|
||||
"""
|
||||
获取设备统计信息 / Get device statistics.
|
||||
|
||||
Returns
|
||||
-------
|
||||
dict
|
||||
{"total": int, "online": int, "offline": int}
|
||||
"""
|
||||
total_result = await db.execute(select(func.count(Device.id)))
|
||||
total = total_result.scalar() or 0
|
||||
|
||||
online_result = await db.execute(
|
||||
select(func.count(Device.id)).where(Device.status == "online")
|
||||
)
|
||||
online = online_result.scalar() or 0
|
||||
|
||||
offline = total - online
|
||||
|
||||
return {
|
||||
"total": total,
|
||||
"online": online,
|
||||
"offline": offline,
|
||||
}
|
||||
183
app/services/location_service.py
Normal file
183
app/services/location_service.py
Normal file
@@ -0,0 +1,183 @@
|
||||
"""
|
||||
Location Service - 位置数据服务
|
||||
Provides query operations for GPS / LBS / WIFI location records.
|
||||
"""
|
||||
|
||||
from datetime import datetime
|
||||
|
||||
from sqlalchemy import func, select
|
||||
from sqlalchemy.ext.asyncio import AsyncSession
|
||||
|
||||
from app.models import LocationRecord
|
||||
|
||||
|
||||
async def get_locations(
|
||||
db: AsyncSession,
|
||||
device_id: int | None = None,
|
||||
location_type: str | None = None,
|
||||
start_time: datetime | None = None,
|
||||
end_time: datetime | None = None,
|
||||
page: int = 1,
|
||||
page_size: int = 20,
|
||||
) -> tuple[list[LocationRecord], int]:
|
||||
"""
|
||||
获取位置记录列表（分页）/ Get paginated location records.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
device_id : int, optional
|
||||
Filter by device ID.
|
||||
location_type : str, optional
|
||||
Filter by location type (gps, lbs, wifi, gps_4g, lbs_4g, wifi_4g).
|
||||
start_time : datetime, optional
|
||||
Filter records after this time.
|
||||
end_time : datetime, optional
|
||||
Filter records before this time.
|
||||
page : int
|
||||
Page number (1-indexed).
|
||||
page_size : int
|
||||
Number of items per page.
|
||||
|
||||
Returns
|
||||
-------
|
||||
tuple[list[LocationRecord], int]
|
||||
(list of location records, total count)
|
||||
"""
|
||||
query = select(LocationRecord)
|
||||
count_query = select(func.count(LocationRecord.id))
|
||||
|
||||
if device_id is not None:
|
||||
query = query.where(LocationRecord.device_id == device_id)
|
||||
count_query = count_query.where(LocationRecord.device_id == device_id)
|
||||
|
||||
if location_type:
|
||||
query = query.where(LocationRecord.location_type == location_type)
|
||||
count_query = count_query.where(LocationRecord.location_type == location_type)
|
||||
|
||||
if start_time:
|
||||
query = query.where(LocationRecord.recorded_at >= start_time)
|
||||
count_query = count_query.where(LocationRecord.recorded_at >= start_time)
|
||||
|
||||
if end_time:
|
||||
query = query.where(LocationRecord.recorded_at <= end_time)
|
||||
count_query = count_query.where(LocationRecord.recorded_at <= end_time)
|
||||
|
||||
total_result = await db.execute(count_query)
|
||||
total = total_result.scalar() or 0
|
||||
|
||||
offset = (page - 1) * page_size
|
||||
query = query.order_by(LocationRecord.recorded_at.desc()).offset(offset).limit(page_size)
|
||||
result = await db.execute(query)
|
||||
records = list(result.scalars().all())
|
||||
|
||||
return records, total
|
||||
|
||||
|
||||
async def get_latest_location(
|
||||
db: AsyncSession, device_id: int
|
||||
) -> LocationRecord | None:
|
||||
"""
|
||||
获取设备最新位置 / Get the most recent location for a device.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
device_id : int
|
||||
Device ID.
|
||||
|
||||
Returns
|
||||
-------
|
||||
LocationRecord | None
|
||||
"""
|
||||
result = await db.execute(
|
||||
select(LocationRecord)
|
||||
.where(LocationRecord.device_id == device_id)
|
||||
.order_by(LocationRecord.recorded_at.desc())
|
||||
.limit(1)
|
||||
)
|
||||
return result.scalar_one_or_none()
|
||||
|
||||
|
||||
async def get_batch_latest_locations(
|
||||
db: AsyncSession, device_ids: list[int]
|
||||
) -> list[LocationRecord]:
|
||||
"""
|
||||
批量获取多设备最新位置 / Get the most recent location for each device in the list.
|
||||
|
||||
Uses a subquery with MAX(id) GROUP BY device_id for efficiency.
|
||||
"""
|
||||
if not device_ids:
|
||||
return []
|
||||
|
||||
# Subquery: max id per device_id
|
||||
subq = (
|
||||
select(func.max(LocationRecord.id).label("max_id"))
|
||||
.where(LocationRecord.device_id.in_(device_ids))
|
||||
.group_by(LocationRecord.device_id)
|
||||
.subquery()
|
||||
)
|
||||
result = await db.execute(
|
||||
select(LocationRecord).where(LocationRecord.id.in_(select(subq.c.max_id)))
|
||||
)
|
||||
return list(result.scalars().all())
|
||||
|
||||
|
||||
async def get_all_online_latest_locations(
|
||||
db: AsyncSession,
|
||||
) -> list[LocationRecord]:
|
||||
"""
|
||||
获取所有在线设备的最新位置 / Get latest location for all online devices.
|
||||
"""
|
||||
from app.models import Device
|
||||
|
||||
# Get online device IDs
|
||||
online_result = await db.execute(
|
||||
select(Device.id).where(Device.status == "online")
|
||||
)
|
||||
online_ids = [row[0] for row in online_result.all()]
|
||||
if not online_ids:
|
||||
return []
|
||||
|
||||
return await get_batch_latest_locations(db, online_ids)
|
||||
|
||||
|
||||
async def get_device_track(
|
||||
db: AsyncSession,
|
||||
device_id: int,
|
||||
start_time: datetime,
|
||||
end_time: datetime,
|
||||
max_points: int = 10000,
|
||||
) -> list[LocationRecord]:
|
||||
"""
|
||||
获取设备轨迹 / Get device movement track within a time range.
|
||||
|
||||
Parameters
|
||||
----------
|
||||
db : AsyncSession
|
||||
Database session.
|
||||
device_id : int
|
||||
Device ID.
|
||||
start_time : datetime
|
||||
Start of time range.
|
||||
end_time : datetime
|
||||
End of time range.
|
||||
|
||||
Returns
|
||||
-------
|
||||
list[LocationRecord]
|
||||
Location records ordered by recorded_at ascending (chronological).
|
||||
"""
|
||||
result = await db.execute(
|
||||
select(LocationRecord)
|
||||
.where(
|
||||
LocationRecord.device_id == device_id,
|
||||
LocationRecord.recorded_at >= start_time,
|
||||
LocationRecord.recorded_at <= end_time,
|
||||
)
|
||||
.order_by(LocationRecord.recorded_at.asc())
|
||||
.limit(max_points)
|
||||
)
|
||||
return list(result.scalars().all())
|
||||
31
app/services/tcp_command_service.py
Normal file
31
app/services/tcp_command_service.py
Normal file
@@ -0,0 +1,31 @@
|
||||
"""
|
||||
TCP Command Service — Abstraction layer for sending commands to devices via TCP.
|
||||
|
||||
Breaks the circular import between routers/commands.py and tcp_server.py
|
||||
by lazily importing tcp_manager only when needed.
|
||||
"""
|
||||
|
||||
import logging
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
def _get_tcp_manager():
|
||||
"""Lazily import tcp_manager to avoid circular imports."""
|
||||
from app.tcp_server import tcp_manager
|
||||
return tcp_manager
|
||||
|
||||
|
||||
def is_device_online(imei: str) -> bool:
|
||||
"""Check if a device is currently connected via TCP."""
|
||||
return imei in _get_tcp_manager().connections
|
||||
|
||||
|
||||
async def send_command(imei: str, command_type: str, command_content: str) -> bool:
|
||||
"""Send an online command (0x80) to a connected device."""
|
||||
return await _get_tcp_manager().send_command(imei, command_type, command_content)
|
||||
|
||||
|
||||
async def send_message(imei: str, message: str) -> bool:
|
||||
"""Send a text message (0x82) to a connected device."""
|
||||
return await _get_tcp_manager().send_message(imei, message)
|
||||
Reference in New Issue
Block a user