Uskunani integratsiya qilish — API

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
EKO-NAZORAT — Integratsiya namunaviy serveri (REFERENCE / EXAMPLE)
=================================================================

Ushbu dastur korxona tomonida ishlaydi:

  1) COM (serial) port orqali gaz-analizator / monitoring stansiyasidan
     o'lchov ma'lumotlarini uzluksiz o'qiydi;
  2) o'qilgan oxirgi qiymatlarni EKO-NAZORAT hujjatidagi JSON formatida
     `GET /api/device-data` endpointida host qilib turadi;
  3) endpoint autentifikatsiya bilan himoyalangan (Basic Auth yoki Bearer).

Ekologiya vazirligining Situatsion markazi shu endpointdan (VPN/HTTPS orqali)
ma'lumotni davriy tortib oladi.

Bu — NAMUNA. `SOZLAMALAR` bo'limini va `parse_serial_line()` funksiyasini
o'z uskunangiz protokoliga moslang.

Talablar:  Python 3.8+,  pip install flask pyserial
Ishga tushirish:  python eco_integration_server.py
"""

import base64
import json
import random
import threading
import time
from datetime import datetime, timezone, timedelta
from functools import wraps

from flask import Flask, Response, jsonify, request

try:
    import serial  # pyserial
except ImportError:
    serial = None  # COM port bo'lmasa — simulyatsiya rejimi ishlaydi


# ═══════════════════════════════════════════════════════════════════════
#  SOZLAMALAR  —  shu bo'limni o'zingizga moslang
# ═══════════════════════════════════════════════════════════════════════

# ── Server ──────────────────────────────────────────────────────────────
HOST = "0.0.0.0"     # barcha interfeyslar (VPN/tarmoq orqali kirish uchun)
PORT = 8080

# ── Autentifikatsiya (MAJBURIY) ─────────────────────────────────────────
# "basic"  → login/parol;   "bearer" → token
AUTH_TYPE = "basic"
BASIC_USER = "ekonazorat"
BASIC_PASS = "StrongParol123!"          # ← albatta o'zgartiring
BEARER_TOKEN = "almashtiring-uzun-tasodifiy-token"

# ── Vaqt mintaqasi (Toshkent = UTC+5) ───────────────────────────────────
TASHKENT_TZ = timezone(timedelta(hours=5))

# ── Manba (stansiya) metadatasi ─────────────────────────────────────────
STATION = {
    "manbaraqami":       "TSH-0102-001",          # unikal davlat manba raqami
    "name":              "1-quvur (tutun mo'risi)",
    "organization_name": '"Korxona" MChJ',
    "tashkilot_inn":     "301234567",
    "address":           "Toshkent viloyati, Angren sh.",
    "stansiya":          "CEMS",                   # CEMS=sanoat manbasi, AQMS=fon
    "trubadiametri":     "1200mm",
    "latitude":          41.0167,
    "longitude":         70.1436,
}

# ── COM (serial) port sozlamalari ───────────────────────────────────────
# COM_PORT = None  bo'lsa yoki port ochilmasa → SIMULYATSIYA rejimi yoqiladi
# Windows:  "COM3"      Linux:  "/dev/ttyUSB0"
COM_PORT = None
BAUDRATE = 9600
SERIAL_TIMEOUT = 2  # soniya

# ── Parametrlar xaritasi ────────────────────────────────────────────────
# (standart_kalit, birlik, analizator_liniyasidagi_xom_nom, toliq_nom)
# - Standart kalitlar uchun `name` ni bo'sh qoldiring.
# - Jadvalda YO'Q (nostandart) moddalar uchun `name` ni to'ldiring
#   (masalan benzol, fenol) — qo'mita mapping'ni shunga qarab sozlaydi.
PARAMETERS = [
    # kalit          birlik      xom nom     to'liq nom (nostandart uchun)
    ("so2",          "mg/m³",    "SO2",      ""),
    ("no2",          "mg/m³",    "NO2",      ""),
    ("co",           "mg/m³",    "CO",       ""),
    ("dust",         "mg/m³",    "DUST",     ""),
    ("o2",           "%",        "O2",       ""),
    ("temperature",  "°C",       "T",        ""),
    ("gas_flow",     "m³/soat",  "FLOW",     ""),
    # ── nostandart modda misoli (PDV'dan) ──
    ("benzol",       "mg/m³",    "BENZOL",   "Benzol"),
    ("fenol",        "mg/m³",    "FENOL",    "Fenol"),
]


# ═══════════════════════════════════════════════════════════════════════
#  Oxirgi o'lchov — thread-safe ombor
# ═══════════════════════════════════════════════════════════════════════

_latest_lock = threading.Lock()
_latest_values = {}          # {xom_nom: float}
_latest_ts = None            # datetime (o'lchov vaqti)


def _set_latest(values: dict):
    global _latest_values, _latest_ts
    with _latest_lock:
        _latest_values = dict(values)
        _latest_ts = datetime.now(TASHKENT_TZ)


def _get_latest():
    with _latest_lock:
        return dict(_latest_values), _latest_ts


# ═══════════════════════════════════════════════════════════════════════
#  COM port o'quvchi  —  fon oqimda uzluksiz ishlaydi
# ═══════════════════════════════════════════════════════════════════════

def parse_serial_line(line: str) -> dict:
    """
    Analizatordan kelgan bitta matn qatorini {xom_nom: float} ga aylantiradi.

    NAMUNA format (o'zingiznikiga moslang):
        SO2:0.42;NO2:0.18;CO:3.10;DUST:0.05;O2:6.5;T:145.0;FLOW:12000

    Ko'p analizatorlar Modbus RTU (RS-485) ishlatadi — u holda `pymodbus`
    kutubxonasidan foydalanib registrlarni o'qing va shu dict'ni qaytaring.
    """
    result = {}
    line = line.strip()
    if not line:
        return result
    for token in line.replace(",", ";").split(";"):
        if ":" not in token:
            continue
        raw_name, raw_val = token.split(":", 1)
        raw_name = raw_name.strip().upper()
        try:
            result[raw_name] = float(raw_val.strip().replace(",", "."))
        except ValueError:
            continue
    return result


def serial_reader_loop():
    """COM portni ochib, uzluksiz o'qiydi. Port bo'lmasa — simulyatsiya."""
    if serial is None or not COM_PORT:
        print("⚠  COM port sozlanmagan yoki pyserial yo'q — SIMULYATSIYA rejimi.")
        _simulation_loop()
        return

    while True:
        try:
            with serial.Serial(COM_PORT, BAUDRATE, timeout=SERIAL_TIMEOUT) as ser:
                print(f"✅ COM port ochildi: {COM_PORT} @ {BAUDRATE}")
                while True:
                    raw = ser.readline().decode("ascii", errors="ignore")
                    values = parse_serial_line(raw)
                    if values:
                        _set_latest(values)
        except Exception as e:
            print(f"🟥 COM port xatosi: {e} — 5s dan keyin qayta urinaman...")
            time.sleep(5)


def _simulation_loop():
    """Uskuna ulanmagan holda API'ni sinash uchun tasodifiy qiymatlar."""
    base = {
        "SO2": 0.40, "NO2": 0.18, "CO": 3.0, "DUST": 0.05, "O2": 6.5,
        "T": 145.0, "FLOW": 12000, "BENZOL": 0.002, "FENOL": 0.001,
    }
    while True:
        values = {k: round(v * random.uniform(0.85, 1.15), 4) for k, v in base.items()}
        _set_latest(values)
        time.sleep(5)


# ═══════════════════════════════════════════════════════════════════════
#  Autentifikatsiya
# ═══════════════════════════════════════════════════════════════════════

def _check_auth() -> bool:
    hdr = request.headers.get("Authorization", "")
    if AUTH_TYPE == "basic":
        if not hdr.startswith("Basic "):
            return False
        try:
            decoded = base64.b64decode(hdr[6:]).decode("utf-8")
            user, _, pwd = decoded.partition(":")
        except Exception:
            return False
        return user == BASIC_USER and pwd == BASIC_PASS
    elif AUTH_TYPE == "bearer":
        return hdr == f"Bearer {BEARER_TOKEN}"
    return False


def require_auth(fn):
    @wraps(fn)
    def wrapper(*args, **kwargs):
        if not _check_auth():
            resp = Response(
                json.dumps({"error": "Autentifikatsiya talab qilinadi"}),
                status=401, mimetype="application/json",
            )
            if AUTH_TYPE == "basic":
                resp.headers["WWW-Authenticate"] = 'Basic realm="eko-nazorat"'
            return resp
        return fn(*args, **kwargs)
    return wrapper


# ═══════════════════════════════════════════════════════════════════════
#  JSON javobni yig'ish
# ═══════════════════════════════════════════════════════════════════════

def build_payload():
    values, ts = _get_latest()
    if ts is None:
        ts = datetime.now(TASHKENT_TZ)

    data = []
    for key, unit, raw_name, full_name in PARAMETERS:
        if raw_name not in values:
            continue
        item = {"parameter": key, "value": values[raw_name], "unit": unit}
        if full_name:                       # nostandart modda — to'liq nom
            item["name"] = full_name
        data.append(item)

    station = dict(STATION)
    station["timestamp"] = ts.isoformat()
    station["devices"] = [{"data": data}]
    return [station]                        # hujjat bo'yicha — massiv (array)


# ═══════════════════════════════════════════════════════════════════════
#  Flask ilova
# ═══════════════════════════════════════════════════════════════════════

app = Flask(__name__)


@app.route("/api/device-data", methods=["GET"])
@require_auth
def device_data():
    payload = build_payload()
    return Response(
        json.dumps(payload, ensure_ascii=False),
        mimetype="application/json",
    )


@app.route("/health", methods=["GET"])
def health():
    _, ts = _get_latest()
    return jsonify({
        "status": "ok",
        "last_reading": ts.isoformat() if ts else None,
        "mode": "serial" if (serial and COM_PORT) else "simulation",
    })


def main():
    # COM port o'quvchini fon oqimda ishga tushiramiz
    t = threading.Thread(target=serial_reader_loop, daemon=True)
    t.start()

    print("─" * 60)
    print(f"  EKO-NAZORAT integratsiya serveri")
    print(f"  Endpoint : http://{HOST}:{PORT}/api/device-data")
    print(f"  Auth     : {AUTH_TYPE}")
    print(f"  Manba    : {STATION['manbaraqami']} — {STATION['name']}")
    print("─" * 60)

    # DIQQAT: ishlab chiqarishda HTTPS (TLS) yoki VPN ortidan ishlating.
    app.run(host=HOST, port=PORT, threaded=True)


if __name__ == "__main__":
    main()