# _*_ coding:utf-8 _*_
import os
import uuid
from datetime import datetime

import app.api.response
from app import db
from . import admin
from flask import render_template, redirect, url_for, flash, session, request, g, abort, make_response, current_app
from app.admin.forms import LoginForm, PwdForm, AreaForm, ScenicForm, TravelsForm, DeviceForm, DeviceTypeForm, \
    DetectingPointForm, AdminForm, PowerForm, RoleForm, UserForm
from app.models import Admin, Adminlog, Oplog, Userlog, Area, User, Suggestion, Scenic, Travels, DeviceType, Device, \
    DetectingPoint, Role, Power, Alarm, Notification
from werkzeug.utils import secure_filename
from sqlalchemy import or_, and_, func
from functools import wraps
from app.config import DeviceType as DT
from app.api.stack_func import get_stack

current_user = ""


def get_generate_password_hash(pwd):
    from werkzeug.security import generate_password_hash
    return generate_password_hash(password=pwd)


def is_valid_time_format(time_str):
    # print("time_str="+time_str)
    try:
        datetime.strptime(time_str, "%Y-%m-%d %H:%M")
        return True
    except ValueError:
        return False


def admin_login(f):
    """
    登录装饰器
    """

    @wraps(f)
    def decorated_function(*args, **kwargs):
        if "admin" not in session:
            return redirect(url_for("admin.login", next=request.url))
        return f(*args, **kwargs)

    return decorated_function


def addOplog(reason):
    oplog = Oplog(
        admin_id=session["admin_id"],
        ip=request.remote_addr,
        reason=reason
    )
    db.session.add(oplog)
    db.session.commit()


def gen_rnd_filename():
    return datetime.now().strftime("%Y%m%d%H%M%S") + str(uuid.uuid4().hex)


def change_filename(filename):
    """
    修改文件名称
    """
    fileinfo = os.path.splitext(filename)
    filename = gen_rnd_filename() + fileinfo[-1]
    return filename


@admin.route("/")
@admin_login
def index():
    days = datetime.strptime(f'{datetime.now().year}-{datetime.now().month}-{datetime.now().day} 00:00',
                             "%Y-%m-%d %H:%M")

    device_data = Device.query.group_by(
        Device.devicetype_id
    ).order_by(
        Device.devicetype_id.asc()
    ).all()
    for d in device_data:
        print(d.devicetype.type)

    video = Alarm.query.join(
        Device
    ).join(
        DeviceType
    ).filter(
        Alarm.device_id == Device.id
    ).filter(
        Device.devicetype_id == DT.Video
    ).filter(
        days < Alarm.addtime
    ).order_by(
        Alarm.addtime.desc()
    ).paginate(page=1, per_page=10)

    gasc = Alarm.query.join(
        Device
    ).filter(
        Device.id == Alarm.device_id,
    ).filter(
        days < Alarm.addtime
    ).filter(
        Device.devicetype_id == DT.GasConcentration
    ).order_by(
        Alarm.addtime.desc()
    ).paginate(page=1, per_page=3)
    if gasc.items is None or len(gasc.items) == 0:
        gasc = None

    pressure = Alarm.query.join(
        Device
    ).filter(
        Device.id == Alarm.device_id,
    ).filter(
        days < Alarm.addtime
    ).filter(
        Device.devicetype_id == DT.Pressure
    ).order_by(
        Alarm.addtime.desc()
    ).paginate(page=1, per_page=3)
    if pressure.items is None or len(pressure.items) == 0:
        pressure = None

    radar = Alarm.query.join(
        Device
    ).filter(
        Device.id == Alarm.device_id,
    ).filter(
        days < Alarm.addtime
    ).filter(
        Device.devicetype_id == DT.Radar
    ).order_by(
        Alarm.addtime.desc()
    ).paginate(page=1, per_page=3)
    if radar.items is None or len(radar.items) == 0:
        radar = None

    return render_template("admin/index.html",
                           video=video, gasc=gasc, pressure=pressure,
                           device_data=device_data, radar=radar,
                           s_url=request.host_url, year=datetime.now().year)


@admin.route("/login/", methods=["GET", "POST"])
def login():
    """
    登录功能
    """
    form = LoginForm()  # 实例化登录表单
    if form.validate_on_submit():  # 验证提交表单
        data = form.data  # 接收数据
        admin = Admin.query.filter_by(name=data["account"]).first()  # 查找Admin表数据
        # 密码错误时，check_pwd返回false,则此时not check_pwd(data["pwd"])为真。
        if not admin.check_pwd(data["pwd"]):
            flash("密码错误!", "err")  # 闪存错误信息
            return redirect(url_for("admin.login"))  # 跳转到后台登录页
        # 如果是正确的，就要定义session的会话进行保存。
        session["admin"] = data["account"]  # 存入session
        session["admin_id"] = admin.id  # 存入session
        # 创建数据
        adminlog = Adminlog(
            admin_id=admin.id,
            ip=request.remote_addr,
        )
        db.session.add(adminlog)  # 添加数据
        db.session.commit()  # 提交数据
        next_url = request.args.get('next') or url_for('admin.index')
        global current_user
        current_user = (data['account'])

        return redirect(next_url)
        # return redirect(url_for("admin.index"))  # 返回后台主页

    return render_template("admin/login.html", form=form, year=datetime.now().year)


@admin.route('/logout/')
@admin_login
def logout():
    """
    后台注销登录
    """
    session.pop("admin", None)
    session.pop("admin_id", None)
    return redirect(url_for("admin.login"))


@admin.route('/pwd/', methods=["GET", "POST"])
@admin_login
def pwd():
    """
    后台密码修改
    """
    form = PwdForm()
    if form.validate_on_submit():
        data = form.data
        admin = Admin.query.filter_by(name=session["admin"]).first()
        from werkzeug.security import generate_password_hash
        admin.pwd = generate_password_hash(data["new_pwd"])
        db.session.add(admin)
        db.session.commit()
        flash("修改密码成功，请重新登录！", "ok")
        return redirect(url_for('admin.logout'))
    return render_template("admin/pwd.html", form=form, year=datetime.now().year)


@admin.route("/user/add/", methods=["GET", "POST"])
@admin_login
def user_add():
    form = UserForm(False)
    form.role_id.choices = [(v.id, v.name) for v in Role.query.order_by(func.length(Role.name)).all()]  # 为role_id添加属性
    form.power_id.choices = [(v.id, v.name) for v in Power.query.filter(Power.name.notlike("%管理员%")).order_by(
        func.length(Power.name)).all()]  # 为power_id添加属性

    if form.validate_on_submit():
        data = form.data  # 接收数据
        print(data['pwd'])
        count = User.query.filter_by(username=data["username"]).count()
        # 说明已存在
        if count == 1:
            flash("用户名已存在", "err")
            return redirect(url_for("admin.user_add"))

        user = User(
            username=data["username"],
            email=data["email"],
            phone=data["phone"],
            pwd=get_generate_password_hash(data['pwd']),

            role_id=data['role_id'],
            power_id=data['power_id'],
        )
        db.session.add(user)
        db.session.commit()
        addOplog("添加用户" + data["username"])  # 添加日志
        flash("用户添加成功", "ok")
        return redirect(url_for("admin.user_add"))

    return render_template("admin/user_add.html", form=form, year=datetime.now().year)


@admin.route("/user/list/", methods=["GET"])
@admin_login
def user_list():
    """
    会员列表
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    keyword = request.args.get('keyword', '', type=str)

    if keyword:
        # 根据姓名或者邮箱查询
        filters = or_(User.username == keyword, User.email == keyword)
        page_data = User.query.filter(filters).order_by(
            User.addtime.desc()
        ).paginate(page=page, per_page=5)
    else:
        page_data = User.query.order_by(
            User.addtime.desc()
        ).paginate(page=page, per_page=5)

    return render_template("admin/user_list.html", page_data=page_data, year=datetime.now().year)


@admin.route("/email/notification/", methods=["GET"])
@admin_login
def email_notification():
    """
    邮件通知
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    keyword = request.args.get('keyword', '', type=str)

    if keyword:
        # 根据姓名或者邮箱查询
        filters = or_(User.email == keyword)
        page_data = User.query.filter(
            User.email is not None
        ).filter(filters).order_by(
            User.addtime.desc()
        ).paginate(page=page, per_page=10)
    else:
        page_data = User.query.filter(
            User.email is not None
        ).order_by(
            User.addtime.desc()
        ).paginate(page=page, per_page=10)

    return render_template("admin/email_notification.html", page_data=page_data, year=datetime.now().year)


@admin.route("/phone/notification/", methods=["GET"])
@admin_login
def phone_notification():
    """
    邮件通知
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    keyword = request.args.get('keyword', '', type=str)

    if keyword:
        # 根据姓名或者邮箱查询
        filters = or_(User.phone == keyword)
        page_data = User.query.filter(
            User.phone is not None
        ).filter(filters).order_by(
            User.addtime.desc()
        ).paginate(page=page, per_page=10)
    else:
        page_data = User.query.filter(
            User.phone is not None
        ).order_by(
            User.addtime.desc()
        ).paginate(page=page, per_page=10)

    return render_template("admin/phone_notification.html", page_data=page_data, year=datetime.now().year)


@admin.route('/power/add/', methods=["GET", "POST"])
@admin_login
def power_add():
    """
    添加权限
    """
    form = PowerForm()
    if form.validate_on_submit():
        data = form.data  # 接收数据
        count = Power.query.filter_by(name=data["name"]).count()
        # 说明已经有这个类型名称了
        if count == 1:
            flash("权限名称已存在", "err")
            return redirect(url_for("admin.power_add"))
        power = Power(
            name=data["name"],
        )
        db.session.add(power)
        db.session.commit()
        addOplog("添加权限 " + data["name"])  # 添加日志
        flash("权限添加成功", "ok")
        return redirect(url_for("admin.power_add"))
    return render_template("admin/power_add.html", form=form, year=datetime.now().year)


@admin.route("/power/list/", methods=["GET", "POST"])
@admin_login
def power_list():
    """
    管理员列表
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    keywords = request.args.get('keywords', '', type=str)

    if keywords:
        # 根据姓名或者邮箱查询
        filters = or_(Power.name.like("%{0}%".format(keywords)))
        page_data = Power.query.filter(filters).order_by(
            Power.addtime.desc()
        ).paginate(page=page, per_page=5)
    else:
        page_data = Power.query.order_by(
            Power.addtime.desc()
        ).paginate(page=page, per_page=5)

    return render_template("admin/power_list.html", page_data=page_data, year=datetime.now().year)


@admin.route("/power/edit/<int:id>", methods=["GET", "POST"])
@admin_login
def power_edit(id=None):
    """
    编辑权限页面
    """

    form = PowerForm()  # 实例化
    form.submit.label.text = "修改"  # 修改提交按钮的文字

    power = Power.query.get_or_404(int(id))  # 根据ID查找

    if request.method == "GET":  # 如果以GET方式提交，获取所有设备信息
        form.name.data = power.name

    if form.validate_on_submit():  # 如果提交表单
        data = form.data  # 获取表单数据

        count = Power.query.filter_by(name=data["name"]).count()
        if count == 1:
            flash("权限名称已存在", "err")
            return redirect(url_for("admin.power_edit", id=id))

        # 属性赋值
        power.name = data["name"]

        db.session.commit()  # 提交数据
        flash("修改权限成功！", "ok")
        return redirect(url_for('admin.power_edit', id=id))  # 跳转到编辑页面
    return render_template("admin/power_edit.html", form=form, year=datetime.now().year)  # 渲染模板，传递变量


@admin.route("/power/del/<int:id>", methods=["GET", "POST"])
@admin_login
def power_del(id=None):
    """
    删除管理员
    """
    page = request.args.get('page', 1, type=int)
    power = Power.query.get_or_404(int(id))
    db.session.delete(power)
    db.session.commit()
    addOplog("删除权限 " + power.name)  # 添加日志
    flash("删除权限成功！", "ok")
    return redirect(url_for('admin.power_list', page=page))


@admin.route('/role/add/', methods=["GET", "POST"])
@admin_login
def role_add():
    """
    添加权限
    """
    form = RoleForm()
    if form.validate_on_submit():
        data = form.data  # 接收数据
        count = Role.query.filter_by(name=data["name"]).count()
        # 说明已经有这个类型名称了
        if count == 1:
            flash("角色名称已存在", "err")
            return redirect(url_for("admin.role_add"))
        role = Role(
            name=data["name"],
        )
        db.session.add(role)
        db.session.commit()
        addOplog("添加角色 " + data["name"])  # 添加日志
        flash("角色添加成功", "ok")
        return redirect(url_for("admin.role_add"))
    return render_template("admin/role_add.html", form=form, year=datetime.now().year)


@admin.route("/role/list/", methods=["GET", "POST"])
@admin_login
def role_list():
    """
    管理员列表
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    keywords = request.args.get('keywords', '', type=str)

    if keywords:
        # 根据姓名或者邮箱查询
        filters = or_(Role.name.like("%{0}%".format(keywords)))
        page_data = Role.query.filter(filters).order_by(
            Role.addtime.desc()
        ).paginate(page=page, per_page=5)
    else:
        page_data = Role.query.order_by(
            Role.addtime.desc()
        ).paginate(page=page, per_page=5)

    return render_template("admin/role_list.html", page_data=page_data, year=datetime.now().year)


@admin.route("/role/edit/<int:id>", methods=["GET", "POST"])
@admin_login
def role_edit(id=None):
    """
    编辑管理员页面
    """

    form = RoleForm()  # 实例化
    form.submit.label.text = "修改"  # 修改提交按钮的文字

    role = Role.query.get_or_404(int(id))  # 根据ID查找

    if request.method == "GET":  # 如果以GET方式提交，获取所有设备信息
        form.name.data = role.name

    if form.validate_on_submit():  # 如果提交表单
        data = form.data  # 获取表单数据

        count = Role.query.filter_by(name=data["name"]).count()
        if count == 1:
            flash("角色名称已存在", "err")
            return redirect(url_for("admin.power_edit", id=id))

        # 属性赋值
        role.name = data["name"]

        db.session.commit()  # 提交数据
        flash("修改角色成功！", "ok")
        return redirect(url_for('admin.role_edit', id=id))  # 跳转到编辑页面
    return render_template("admin/role_edit.html", form=form, year=datetime.now().year)  # 渲染模板，传递变量


@admin.route("/role/del/<int:id>", methods=["GET", "POST"])
@admin_login
def role_del(id=None):
    """
    删除管理员
    """
    page = request.args.get('page', 1, type=int)
    role = Role.query.get_or_404(int(id))
    db.session.delete(role)
    db.session.commit()
    addOplog("删除角色" + role.name)  # 添加日志
    flash("删除管理员成功！", "ok")
    return redirect(url_for('admin.role_list', page=page))


@admin.route("/admin/list/", methods=["GET", "POST"])
@admin_login
def admin_list():
    """
    管理员列表
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    keywords = request.args.get('keywords', '', type=str)

    if keywords:
        # 根据姓名或者邮箱查询
        filters = or_(Admin.name.like("%{0}%".format(keywords)))
        page_data = Admin.query.filter(filters).order_by(
            Admin.addtime.desc()
        ).paginate(page=page, per_page=10)
    else:
        page_data = Admin.query.order_by(
            Admin.addtime.desc()
        ).paginate(page=page, per_page=10)

    return render_template("admin/admin_list.html", page_data=page_data, year=datetime.now().year)


@admin.route("/admin/add/", methods=["GET", "POST"])
@admin_login
def admin_add():
    """
    添加管理员
    """
    form = AdminForm(False)
    form.role_id.choices = [(v.id, v.name) for v in Role.query.order_by(func.length(Role.name)).all()]  # 为role_id添加属性
    form.power_id.choices = [(v.id, v.name) for v in Power.query.filter(Power.name.like("%管理员%")).order_by(
        func.length(Power.name)).all()]  # 为power_id添加属性

    if form.validate_on_submit():
        data = form.data  # 接收数据
        admin_count = Admin.query.filter_by(name=data["name"]).count()
        # 说明已存在
        if admin_count == 1:
            flash("管理员名称已存在", "err")
            return redirect(url_for("admin.admin_add"))

        admin = Admin(
            name=data["name"],
            pwd=get_generate_password_hash(data['pwd']),

            role_id=data['role_id'],
            power_id=data['power_id'],
        )

        power = Power.query.filter_by(id=data["power_id"]).all()
        if power[0].name == "超级管理员":
            admin.is_super = 1
        else:
            admin.is_super = 0

        db.session.add(admin)
        db.session.commit()
        addOplog("添加管理员" + data["name"])  # 添加日志
        flash("管理员添加成功", "ok")
        return redirect(url_for("admin.admin_add"))
    return render_template("admin/admin_add.html", form=form, year=datetime.now().year)


@admin.route("/admin/edit/<int:id>", methods=["GET", "POST"])
@admin_login
def admin_edit(id=None):
    """
    编辑管理员页面
    """

    form = AdminForm(True)  # 实例化DeviceForm类
    form.power_id.choices = [(v.id, v.name) for v in Power.query.all()]  # 为power_id添加属性
    form.role_id.choices = [(v.id, v.name) for v in Role.query.all()]  # 为role_id添加属性
    form.submit.label.text = "修改"  # 修改提交按钮的文字

    admin = Admin.query.get_or_404(int(id))  # 根据ID查找

    if request.method == "GET":  # 如果以GET方式提交，获取所有设备信息
        form.name.data = admin.name
        form.pwd.data = admin.pwd
        form.repwd.data = admin.pwd
        form.power_id.data = admin.power_id
        form.role_id.data = admin.role_id

    if form.validate_on_submit():  # 如果提交表单
        data = form.data  # 获取表单数据

        # 属性赋值
        admin.name = data["name"]
        admin.pwd = get_generate_password_hash(data["pwd"])
        admin.role_id = int(data["role_id"])
        admin.power_id = int(data["power_id"])

        db.session.commit()  # 提交数据
        flash("修改管理员成功！", "ok")
        return redirect(url_for('admin.admin_edit', id=id))  # 跳转到编辑页面
    return render_template("admin/admin_edit.html", form=form, admin=admin, year=datetime.now().year)  # 渲染模板，传递变量


@admin.route("/admin/del/<int:id>", methods=["GET", "POST"])
@admin_login
def admin_del(id=None):
    """
    删除管理员
    """
    page = request.args.get('page', 1, type=int)
    user = Admin.query.get_or_404(int(id))
    db.session.delete(user)
    db.session.commit()
    addOplog("删除管理员" + user.name)  # 添加日志
    flash("删除管理员成功！", "ok")
    return redirect(url_for('admin.admin_list', page=page))


@admin.route("/user/view/<int:id>/", methods=["GET"])
@admin_login
def user_view(id=None):
    """
    查看会员详情
    """
    from_page = request.args.get('fp')
    if not from_page:
        from_page = 1
    user = User.query.get_or_404(int(id))
    return render_template("admin/user_view.html", user=user, from_page=from_page, year=datetime.now().year)


@admin.route("/user/del/<int:id>/", methods=["GET"])
@admin_login
def user_del(id=None):
    """
    删除会员
    """
    page = request.args.get('page', 1, type=int)
    user = User.query.get_or_404(int(id))
    db.session.delete(user)
    db.session.commit()
    addOplog("删除会员" + user.username)  # 添加日志
    flash("删除会员成功！", "ok")
    return redirect(url_for('admin.user_list', page=page))


@admin.route("/suggestion_list/list/", methods=["GET"])
@admin_login
def suggestion_list():
    """
    意见建议列表
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    page_data = Suggestion.query.order_by(
        Suggestion.addtime.desc()
    ).paginate(page=page, per_page=5)
    return render_template("admin/suggestion_list.html", page_data=page_data, year=datetime.now().year)


@admin.route("/suggestion/del/<int:id>/", methods=["GET"])
@admin_login
def suggestion_del(id=None):
    """
    删除会员
    """
    page = request.args.get('page', 1, type=int)
    suggestion = Suggestion.query.get_or_404(int(id))
    db.session.delete(suggestion)
    db.session.commit()
    addOplog("删除意见建议")  # 添加日志
    flash("删除成功！", "ok")
    return redirect(url_for('admin.suggestion_list', page=page))


@admin.route('/area/add/', methods=["GET", "POST"])
@admin_login
def area_add():
    """
    添加地区
    """
    form = AreaForm()
    if form.validate_on_submit():
        data = form.data  # 接收数据
        area = Area.query.filter_by(name=data["name"]).count()
        # 说明已经有这个地区了
        if area == 1:
            flash("地区已存在", "err")
            return redirect(url_for("admin.area_add"))
        area = Area(
            name=data["name"],
            is_recommended=data['is_recommended'],
            introduction=data['introduction']
        )
        db.session.add(area)
        db.session.commit()
        addOplog("添加地区" + data["name"])  # 添加日志
        flash("地区添加成功", "ok")
        return redirect(url_for("admin.area_add"))
    return render_template("admin/area_add.html", form=form, year=datetime.now().year)


@admin.route('/devicetype/add/', methods=["GET", "POST"])
@admin_login
def devicetype_add():
    """
    添加地区
    """
    form = DeviceTypeForm()
    if form.validate_on_submit():
        data = form.data  # 接收数据
        devicetype = DeviceType.query.filter_by(name=data["name"]).count()
        # 说明已经有这个设备类型名称了
        if devicetype == 1:
            flash("设备类型已存在", "err")
            return redirect(url_for("admin.devicetype_add"))
        devicetype = DeviceType(
            name=data["name"],
            type=data['type'],
        )
        db.session.add(devicetype)
        db.session.commit()
        addOplog("添加设备类型" + data["name"] + " " + data["type"])  # 添加日志
        flash("设备类型添加成功", "ok")
        return redirect(url_for("admin.devicetype_add"))
    return render_template("admin/devicetype_add.html", form=form, year=datetime.now().year)


@admin.route('/detectingpoint/add/', methods=["GET", "POST"])
@admin_login
def detectingpoint_add():
    """
    添加地区
    """
    form = DetectingPointForm()
    if form.validate_on_submit():
        data = form.data  # 接收数据
        detectingpoint = DetectingPoint.query.filter_by(no=data["no"]).filter_by(name=data["name"]).count()
        # 说明已经有这个类型名称了
        if detectingpoint == 1:
            flash("检测点已存在", "err")
            return redirect(url_for("admin.detectingpoint_add"))
        detectingpoint = DetectingPoint(
            name=data["name"],
            no=data['no'],
        )
        db.session.add(detectingpoint)
        db.session.commit()
        addOplog("添加检测点" + data["name"] + " " + data["no"])  # 添加日志
        flash("检测点添加成功", "ok")
        return redirect(url_for("admin.detectingpoint_add"))
    return render_template("admin/detectingpoint_add.html", form=form, year=datetime.now().year)


@admin.route("/area/edit/<int:id>", methods=["GET", "POST"])
@admin_login
def area_edit(id=None):
    """
    地区编辑
    """
    form = AreaForm()
    form.submit.label.text = "修改"
    area = Area.query.get_or_404(id)
    if request.method == "GET":
        form.name.data = area.name
        form.is_recommended.data = area.is_recommended
        form.introduction.data = area.introduction
    if form.validate_on_submit():
        data = form.data
        area_count = Area.query.filter_by(name=data["name"]).count()
        if area.name != data["name"] and area_count == 1:
            flash("景区已存在", "err")
            return redirect(url_for("admin.area_edit", id=area.id))
        area.name = data["name"]
        area.is_recommended = int(data["is_recommended"])
        area.introduction = data["introduction"]
        db.session.add(area)
        db.session.commit()
        flash("标签修改成功", "ok")
        return redirect(url_for("admin.area_edit", id=area.id))
    return render_template("admin/area_edit.html", form=form, area=area, year=datetime.now().year)


@admin.route("/devicetype/edit/<int:type>", methods=["GET", "POST"])
@admin_login
def devicetype_edit(type=None):
    """
    地区编辑
    """
    form = DeviceTypeForm()
    form.submit.label.text = "修改"
    devicetype = DeviceType.query.get_or_404(type)
    if request.method == "GET":
        form.name.data = devicetype.name
        form.type.data = devicetype.type
    if form.validate_on_submit():
        data = form.data
        devicetype_count = DeviceType.query.filter_by(name=data["name"]).count()
        if devicetype.name != data["name"] and devicetype_count == 1:
            flash("设备已存在", "err")
            return redirect(url_for("admin.devicetype_edit", type=devicetype.type))
        devicetype.name = data["name"]
        devicetype.type = int(data["type"])
        db.session.add(devicetype)
        db.session.commit()
        flash("设备类型修改成功", "ok")
        return redirect(url_for("admin.devicetype_edit", type=devicetype.type))
    return render_template("admin/devicetype_edit.html", form=form, devicetype=devicetype, year=datetime.now().year)


@admin.route("/detectingpoint/edit/<int:id>", methods=["GET", "POST"])
@admin_login
def detectingpoint_edit(id=None):
    """
    检测点编辑
    """
    form = DetectingPointForm()
    form.submit.label.text = "修改"
    detectingpoint = DetectingPoint.query.get_or_404(id)
    if request.method == "GET":
        form.name.data = detectingpoint.name
        form.no.data = detectingpoint.no
    if form.validate_on_submit():
        data = form.data
        detectingpoint_count = DetectingPoint.query.filter_by(name=data["name"]).filter_by(no=data["no"]).count()
        if detectingpoint_count == 1:
            flash("检测点已存在", "err")
            return redirect(url_for("admin.detectingpoint_edit", id=detectingpoint.id))
        detectingpoint.name = data["name"]
        detectingpoint.no = int(data["no"])
        db.session.add(detectingpoint)
        db.session.commit()
        flash("检测点修改成功", "ok")
        return redirect(url_for("admin.detectingpoint_edit", id=detectingpoint.id))
    return render_template("admin/detectingpoint_edit.html", form=form, detectingpoint=detectingpoint,
                           year=datetime.now().year)


@admin.route("/area/list/", methods=["GET"])
@admin_login
def area_list():
    """
    标签列表
    """
    name = request.args.get('name', type=str)  # 获取name参数值
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    if name:  # 搜索功能
        page_data = Area.query.filter_by(name=name).order_by(
            Area.addtime.desc()
        ).paginate(page=page, per_page=5)
    else:
        # 查找数据
        page_data = Area.query.order_by(
            Area.addtime.desc()
        ).paginate(page=page, per_page=5)
    return render_template("admin/area_list.html", page_data=page_data, year=datetime.now().year)  # 渲染模板


@admin.route("/devicetype/list/", methods=["GET"])
@admin_login
def devicetype_list():
    """
    标签列表
    """
    name = request.args.get('name', type=str)  # 获取name参数值
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    if name:  # 搜索功能
        page_data = DeviceType.query.filter_by(name=name).order_by(
            DeviceType.addtime.desc()
        ).paginate(page=page, per_page=5)
    else:
        # 查找数据
        page_data = DeviceType.query.order_by(
            DeviceType.addtime.desc()
        ).paginate(page=page, per_page=5)
    return render_template("admin/devicetype_list.html", page_data=page_data, year=datetime.now().year)  # 渲染模板


@admin.route("/detectingpoint/list/", methods=["GET"])
@admin_login
def detectingpoint_list():
    """
    标签列表
    """
    name = request.args.get('name', type=str)  # 获取name参数值
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    if name:  # 搜索功能
        page_data = DetectingPoint.query.filter_by(name=name).order_by(
            DetectingPoint.addtime.desc()
        ).paginate(page=page, per_page=5)
    else:
        # 查找数据
        page_data = DetectingPoint.query.order_by(
            DetectingPoint.addtime.desc()
        ).paginate(page=page, per_page=5)
    return render_template("admin/detectingpoint_list.html", page_data=page_data, year=datetime.now().year)  # 渲染模板


@admin.route("/area/del/<int:id>/", methods=["GET"])
@admin_login
def area_del(id=None):
    """
    标签删除
    """
    # filter_by在查不到或多个的时候并不会报错，get会报错。
    area = Area.query.filter_by(id=id).first_or_404()
    db.session.delete(area)
    db.session.commit()
    addOplog("删除地区" + area.name)  # 添加日志
    flash("地区<<{0}>>删除成功".format(area.name), "ok")
    return redirect(url_for("admin.area_list"))


@admin.route("/devicetype/del/<int:type>/", methods=["GET"])
@admin_login
def devicetype_del(type=None):
    """
    标签删除
    """
    # filter_by在查不到或多个的时候并不会报错，get会报错。
    devicetype = DeviceType.query.filter_by(type=type).first_or_404()
    db.session.delete(devicetype)
    db.session.commit()
    addOplog("删除设备类型" + devicetype.name)  # 添加日志
    flash("设备类型<<{0}>>删除成功".format(devicetype.name), "ok")
    return redirect(url_for("admin.devicetype_list"))


@admin.route("/detectingpoint/del/<int:id>/", methods=["GET"])
@admin_login
def detectingpoint_del(id=None):
    """
    标签删除
    """
    # filter_by在查不到或多个的时候并不会报错，get会报错。
    detectingpoint = DetectingPoint.query.filter_by(id=id).first_or_404()
    db.session.delete(detectingpoint)
    db.session.commit()
    addOplog("删除检测点" + detectingpoint.name + " " + str(detectingpoint.no))  # 添加日志
    flash("检测点<<{0} {1}>>删除成功".format(detectingpoint.name, detectingpoint.no), "ok")
    return redirect(url_for("admin.detectingpoint_list"))


@admin.route("/oplog/list/", methods=["GET"])
@admin_login
def oplog_list():
    """
    操作日志管理
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    page_data = Oplog.query.join(
        Admin
    ).filter(
        Admin.id == Oplog.admin_id,
    ).order_by(
        Oplog.addtime.desc()
    ).paginate(page=page, per_page=10)
    return render_template("admin/oplog_list.html", page_data=page_data, year=datetime.now().year)


last_st = ""
last_et = ""
last_key = ""


@admin.route("/alarm/list/", methods=["GET", "POST"])
@admin_login
def alarm_list():
    """
    报警列表
    """
    st = datetime.now().strftime('%Y-%m-%d 00:00')
    et = datetime.now().strftime('%Y-%m-%d 23:59')

    global last_st
    global last_et
    global last_key

    if request.method == "POST":
        dt1 = request.form.get('datepicker1', '', type=str).replace("T", " ")  # 获取查询标题
        dt2 = request.form.get('datepicker2', '', type=str).replace("T", " ")  # 获取查询标题

        print(f'dt1={dt1}')
        print(f'dt2={dt2}')

        if is_valid_time_format(dt1.replace("T", " ")):
            st = dt1

        if is_valid_time_format(dt2.replace("T", " ")):
            et = dt2

        last_st = st
        last_et = et

        print(f'last_st={last_st}')
        print(f'last_et={last_et}')
        last_key = request.form.get('keywords', '', type=str)  # 获取关键字
        page = request.form.get('page', 1, type=int)  # 获取page参数值
    else:

        if last_st == "":
            last_st = st

        if last_et == "":
            last_et = et

        keywords = request.args.get('keywords', '', type=str)  # 获取关键字
        page = request.args.get('page', 1, type=int)  # 获取page参数值

    page_data = Alarm.query.join(
        Device
    ).filter(
        Device.id == Alarm.device_id,
    ).filter(
        datetime.strptime(last_st, "%Y-%m-%d %H:%M") < Alarm.addtime
    ).filter(
        Alarm.addtime < datetime.strptime(last_et, "%Y-%m-%d %H:%M")
    ).filter(
        Alarm.msg.like("%" + last_key + "%")
    ).order_by(
        Alarm.addtime.desc()
    ).paginate(page=page, per_page=10)
    return render_template("admin/alarm_list.html", key=last_key, st=last_st, et=last_et, page_data=page_data,
                           year=datetime.now().year)


@admin.route("/alarm/edit/", methods=["GET"])
@admin_login
def alarm_edit():
    """
    报警处理
    """
    print("edit")
    no = request.args.get('no')
    msg = request.args.get('msg')
    alarm = Alarm.query.get_or_404(int(no))  # 根据ID查找记录是否存在

    print(f'no={no}')
    print(f'msg={msg}')

    alarm.remark = msg
    alarm.handle = 1
    alarm.handle_user = current_user
    db.session.commit()

    return "1"


@admin.route("/alarm/del/<int:id>/", methods=["GET"])
@admin_login
def alarm_del(id=None):
    """
    删除报警记录
    """
    alarm = Alarm.query.get_or_404(id)  # 根据设备ID查找数据
    db.session.delete(alarm)  # 删除数据
    db.session.commit()  # 提交数据
    flash("记录删除成功", "ok")  # 使用flash存储成功信息
    try:
        addOplog("删除报警记录:" + str(alarm.id) + "(" + alarm.msg + ")")  # 添加日志
    except ValueError:
        pass
    return redirect(url_for('admin.alarm_list', page=1))  # 渲染模板


@admin.route("/alarm/statistics/", methods=["GET", "POST"])
@admin_login
def alarm_statistics():
    """
    报警统计
    """
    st = datetime.now().strftime('%Y-%m-%d 00:00')
    et = datetime.now().strftime('%Y-%m-%d 23:59')
    if request.method == "GET":
        dt1 = request.args.get('datepicker1', '', type=str)  # 获取查询标题
        dt2 = request.args.get('datepicker2', '', type=str)  # 获取查询标题

        if is_valid_time_format(dt1.replace("T", " ")):
            st = dt1
        if is_valid_time_format(dt2.replace("T", " ")):
            et = dt2

    else:
        dt1 = request.form['datepicker1']  # 获取查询标题
        dt2 = request.form['datepicker2']  # 获取查询标题
        print(dt1)
        if is_valid_time_format(dt1.replace("T", " ")):
            st = dt1
        if is_valid_time_format(dt2.replace("T", " ")):
            et = dt2
    print(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
    return render_template("admin/alarm_statistics.html", s_url=request.host_url, st=st, et=et,
                           year=datetime.now().year)


@admin.route("/notification/list/", methods=["GET"])
@admin_login
def notification_list():
    page = request.args.get("page", 1, type=int)
    keywords = request.args.get("keywords", "", type=str)
    page_data = Notification.query.order_by(
        Notification.addtime.desc()
    ).paginate(page=page, per_page=10)

    return render_template("admin/notification_list.html", page_data="", year=datetime.now().year)


@admin.route("/emailnotification_edit", methods=["GET"])
def emailnotification_edit():
    try:

        id = request.args.get("id", 0)
        user = User.query.get_or_404(int(id))  # 根据ID查找设备是否存在

        # 属性赋值
        user.emailnotification = request.args.get('email', 0)

        db.session.commit()  # 提交数据

        return app.api.response.Response(code=200, msg='ok', success=True).json
    except:
        return app.api.response.Response(code=400, msg='err', success=False).json


@admin.route("/phonenotification_edit", methods=["GET"])
def phonenotification_edit():
    try:

        id = request.args.get("id", 0)
        user = User.query.get_or_404(int(id))  # 根据ID查找设备是否存在

        # 属性赋值
        user.phonenotification = request.args.get('phone', 0)

        db.session.commit()  # 提交数据

        return app.api.response.Response(code=200, msg='ok', success=True).json
    except:
        return app.api.response.Response(code=400, msg='err', success=False).json


@admin.route("/adminloginlog/list/", methods=["GET"])
@admin_login
def adminloginlog_list(page=None):
    """
    管理员登录日志
    """
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    page_data = Adminlog.query.join(
        Admin
    ).filter(
        Admin.id == Adminlog.admin_id,
    ).order_by(
        Adminlog.addtime.desc()
    ).paginate(page=page, per_page=10)
    return render_template("admin/adminloginlog_list.html", page_data=page_data, year=datetime.now().year)


@admin.route("/userloginlog/list/", methods=["GET"])
@admin_login
def userloginlog_list(page=None):
    """
    会员登录日志列表
    """
    if page is None:
        page = 1
    page_data = Userlog.query.join(
        User
    ).filter(
        User.id == Userlog.user_id,
    ).order_by(
        Userlog.addtime.desc()
    ).paginate(page=page, per_page=2)
    return render_template("admin/userloginlog_list.html", page_data=page_data, year=datetime.now().year)


@admin.route("/scenic/add/", methods=["GET", "POST"])
@admin_login
def scenic_add():
    """
    添加景区页面
    """
    form = ScenicForm()  # 实例化form表单
    form.area_id.choices = [(v.id, v.name) for v in Area.query.all()]  # 为area_id添加属性
    if form.validate_on_submit():
        data = form.data
        # 判断景区是否存在
        scenic_count = Scenic.query.filter_by(title=data["title"]).count()
        # 判断是否有重复数据。
        if scenic_count == 1:
            flash("景点已经存在！", "err")
            return redirect(url_for('admin.scenic_add'))

        file_logo = secure_filename(form.logo.data.filename)  # 确保文件名
        if not os.path.exists(current_app.config["UP_DIR"]):
            # 创建一个多级目录
            os.makedirs(current_app.config["UP_DIR"])  # 创建文件夹
            os.chmod(current_app.config["UP_DIR"], "rw")  # 设置权限
        logo = change_filename(file_logo)  # 更改名称
        form.logo.data.save(current_app.config["UP_DIR"] + logo)  # 保存文件
        # 为Scenic类属性赋值
        scenic = Scenic(
            title=data["title"],
            logo=logo,
            star=int(data["star"]),
            address=data["address"],
            is_hot=int(data["is_hot"]),
            is_recommended=int(data["is_recommended"]),
            area_id=data["area_id"],
            introduction=data["introduction"],
            content=data["content"],
        )
        db.session.add(scenic)  # 添加数据
        db.session.commit()  # 提交数据
        addOplog("添加景区" + data["title"])  # 添加日志
        flash("添加景区成功！", "ok")  # 使用flash保存添加成功信息
        return redirect(url_for('admin.scenic_add'))  # 页面跳转
    return render_template("admin/scenic_add.html", form=form, year=datetime.now().year)  # 渲染模板


@admin.route("/device/add/", methods=["GET", "POST"])
@admin_login
def device_add():
    """
    添加设备页面
    """
    form = DeviceForm(False)  # 实例化form表单
    form.devicetype_id.choices = [(v.type, v.name) for v in DeviceType.query.all()]  # 为devicetype_id添加属性
    form.detectingpoint_id.choices = [(v.id, v.name + str(v.no)) for v in
                                      DetectingPoint.query.all()]  # 为detectingpoint_id添加属性
    if form.validate_on_submit():
        data = form.data
        # 判断设备是否存在
        # 设备地址以及设备id唯一
        device_count = Device.query.filter_by(devicetype_id=data["devicetype_id"]).filter_by(
            address=data["address"]).count()
        # 判断是否有重复数据。
        if device_count == 1:
            flash("设备已经存在！", "err")
            return redirect(url_for('admin.device_add'))

        file_logo = secure_filename(form.logo.data.filename)  # 确保文件名
        if not os.path.exists(current_app.config["UP_DIR"]):
            # 创建一个多级目录
            os.makedirs(current_app.config["UP_DIR"])  # 创建文件夹
            os.chmod(current_app.config["UP_DIR"], "rw")  # 设置权限
        logo = change_filename(file_logo)  # 更改名称
        form.logo.data.save(current_app.config["UP_DIR"] + logo)  # 保存文件
        # 为Scenic类属性赋值
        device = Device(
            title=data["title"],
            logo=logo,
            address=data["address"],
            threshold=data["threshold"],
            devicetype_id=data["devicetype_id"],
            detectingpoint_id=data["detectingpoint_id"],
            introduction=data["introduction"],
        )
        db.session.add(device)  # 添加数据
        db.session.commit()  # 提交数据
        addOplog("添加设备名称：" + data["title"] + ",地址：" + data["address"])  # 添加日志
        flash("添加设备成功！", "ok")  # 使用flash保存添加成功信息
        return redirect(url_for('admin.device_add'))  # 页面跳转
    return render_template("admin/device_add.html", form=form, year=datetime.now().year)  # 渲染模板


@admin.route("/scenic/list/", methods=["GET"])
@admin_login
def scenic_list():
    """
    景区列表页面
    """
    title = request.args.get('title', '', type=str)  # 获取查询标题
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    if title:  # 根据标题搜索景区
        page_data = Scenic.query.filter_by(title=title).order_by(
            Scenic.addtime.desc()  # 根据添加时间降序
        ).paginate(page=page, per_page=5)  # 分页
    else:  # 显示全部景区
        page_data = Scenic.query.order_by(
            Scenic.addtime.desc()  # 根据添加时间降序
        ).paginate(page=page, per_page=5)  # 分页
    return render_template("admin/scenic_list.html", page_data=page_data, year=datetime.now().year)  # 渲染模板


@admin.route("/device/list/", methods=["GET"])
@admin_login
def device_list():
    """
    设备列表页面
    """
    keywords = request.args.get('keywords', '', type=str)  # 获取查询标题
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    if keywords:  # 根据设备名称搜索
        page_data = Device.query.filter(Device.title.like("%" + keywords + "%")).order_by(
            Device.addtime.desc()  # 根据添加时间降序
        ).paginate(page=page, per_page=5)  # 分页
    else:  # 显示全部设备
        page_data = Device.query.order_by(
            Device.addtime.desc()  # 根据添加时间降序
        ).paginate(page=page, per_page=5)  # 分页
    return render_template("admin/device_list.html", page_data=page_data, year=datetime.now().year)  # 渲染模板


@admin.route("/scenic/edit/<int:id>/", methods=["GET", "POST"])
@admin_login
def scenic_edit(id=None):
    """
    编辑景区页面
    """
    form = ScenicForm()  # 实例化ScenicForm类
    form.area_id.choices = [(v.id, v.name) for v in Area.query.all()]  # 为area_id添加属性
    form.submit.label.text = "修改"  # 修改提交按钮的文字
    form.logo.validators = []  # 初始化为空
    scenic = Scenic.query.get_or_404(int(id))  # 根据ID查找景区是否存在
    if request.method == "GET":  # 如果以GET方式提交，获取所有景区信息
        form.is_recommended.data = scenic.is_recommended
        form.is_hot.data = scenic.is_hot
        form.area_id.data = scenic.area_id
        form.star.data = scenic.star
        form.content.data = scenic.content
        form.introduction.data = scenic.introduction
    if form.validate_on_submit():  # 如果提交表单
        data = form.data  # 获取表单数据
        scenic_count = Scenic.query.filter_by(title=data["title"]).count()  # 判断标题是否重复
        # 判断是否有重复数据
        if scenic_count == 1:
            flash("景点已经存在！", "err")
            return redirect(url_for('admin.scenic_edit', id=id))
        if not os.path.exists(current_app.config["UP_DIR"]):  # 判断目录是否存在
            os.makedirs(current_app.config["UP_DIR"])  # 创建目录
            os.chmod(current_app.config["UP_DIR"], "rw")  # 设置读写权限
        # 上传图片
        if form.logo.data.filename != "":
            file_logo = secure_filename(form.logo.data.filename)  # 确保文件名安全
            scenic.logo = change_filename(file_logo)  # 更改文件名
            form.logo.data.save(current_app.config["UP_DIR"] + scenic.logo)  # 保存文件
        # 属性赋值
        scenic.title = data["title"]
        scenic.address = data["address"]
        scenic.area_id = data["area_id"]
        scenic.star = int(data["star"])
        scenic.is_hot = int(data["is_hot"])
        scenic.is_recommended = int(data["is_recommended"])
        scenic.introduction = data["introduction"]
        scenic.content = data["content"]

        db.session.add(scenic)  # 添加数据
        db.session.commit()  # 提交数据
        flash("修改景区成功！", "ok")
        return redirect(url_for('admin.scenic_edit', id=id))  # 跳转到编辑页面
    return render_template("admin/scenic_edit.html", form=form, scenic=scenic, year=datetime.now().year)  # 渲染模板，传递变量


@admin.route("/device/edit/<int:id>/", methods=["GET", "POST"])
@admin_login
def device_edit(id=None):
    """
    编辑设备页面
    """
    form = DeviceForm(True)  # 实例化DeviceForm类
    form.devicetype_id.choices = [(v.type, v.name) for v in DeviceType.query.all()]  # 为devicetype_id添加属性
    form.detectingpoint_id.choices = [(v.id, v.name + str(v.no)) for v in
                                      DetectingPoint.query.all()]  # 为detectingpoint_id添加属性
    form.submit.label.text = "修改"  # 修改提交按钮的文字
    form.logo.validators = []  # 初始化为空
    device = Device.query.get_or_404(int(id))  # 根据ID查找设备是否存在
    print("================")
    print(form)
    print("================")
    if request.method == "GET":  # 如果以GET方式提交，获取所有设备信息
        form.title.data = device.title
        form.address.data = device.address
        form.threshold.data = device.threshold
        form.logo.data = device.logo
        form.introduction.data = device.introduction
        form.devicetype_id.data = device.devicetype_id
        form.detectingpoint_id.data = device.detectingpoint_id
    if form.validate_on_submit():  # 如果提交表单
        data = form.data  # 获取表单数据

        if not os.path.exists(current_app.config["UP_DIR"]):  # 判断目录是否存在
            os.makedirs(current_app.config["UP_DIR"])  # 创建目录
            os.chmod(current_app.config["UP_DIR"], "rw")  # 设置读写权限
        # 上传图片
        if form.logo.data.filename != "":
            file_logo = secure_filename(form.logo.data.filename)  # 确保文件名安全
            device.logo = change_filename(file_logo)  # 更改文件名
            form.logo.data.save(current_app.config["UP_DIR"] + device.logo)  # 保存文件
        # 属性赋值
        device.title = data["title"]
        device.address = data["address"]
        device.threshold = data["threshold"]
        device.devicetype_id = int(data["devicetype_id"])
        device.detectingpoint_id = int(data["detectingpoint_id"])
        device.introduction = data["introduction"]

        db.session.commit()  # 提交数据
        flash("修改设备成功！", "ok")
        return redirect(url_for('admin.device_edit', id=id))  # 跳转到编辑页面
    return render_template("admin/device_edit.html", form=form, device=device, year=datetime.now().year)  # 渲染模板，传递变量


@admin.route("/scenic/del/<int:id>/", methods=["GET"])
@admin_login
def scenic_del(id=None):
    """
    景区删除
    """
    scenic = Scenic.query.get_or_404(id)  # 根据景区ID查找数据
    db.session.delete(scenic)  # 删除数据
    db.session.commit()  # 提交数据
    flash("景区删除成功", "ok")  # 使用flash存储成功信息
    addOplog("删除景区" + scenic.title)  # 添加日志
    return redirect(url_for('admin.scenic_list', page=1))  # 渲染模板


@admin.route("/device/del/<int:id>/", methods=["GET"])
@admin_login
def device_del(id=None):
    """
    设备删除
    """
    device = Device.query.get_or_404(id)  # 根据设备ID查找数据
    db.session.delete(device)  # 删除数据
    db.session.commit()  # 提交数据
    flash("设备删除成功", "ok")  # 使用flash存储成功信息
    addOplog("删除设备" + device.title + " " + device.address)  # 添加日志
    return redirect(url_for('admin.device_list', page=1))  # 渲染模板


@admin.route("/travels/add/", methods=["GET", "POST"])
@admin_login
def travels_add():
    """
    添加游记
    """
    form = TravelsForm()
    form.scenic_id.choices = [(v.id, v.title) for v in Scenic.query.all()]
    if form.validate_on_submit():
        data = form.data
        # 判断游记是否存在
        travels_count = Travels.query.filter_by(title=data["title"]).count()
        # 判断是否有重复数据。
        if travels_count == 1:
            flash("景点已经存在！", "err")
            return redirect(url_for('admin.travels_add'))
        travels = Travels(
            title=data["title"],
            author=data["author"],
            scenic_id=data["scenic_id"],
            content=data["content"],
        )
        db.session.add(travels)
        db.session.commit()
        addOplog("添加游记" + data["title"])  # 添加日志
        flash("添加游记成功！", "ok")
        return redirect(url_for('admin.travels_add'))
    return render_template("admin/travels_add.html", form=form, year=datetime.now().year)


@admin.route("/travels/list/", methods=["GET"])
@admin_login
def travels_list():
    """
    景区列表页面
    """
    keywords = request.args.get('keywords', '', type=str)
    page = request.args.get('page', 1, type=int)  # 获取page参数值
    if keywords:
        # 使用like实现模糊查询
        page_data = Travels.query.filter(Travels.title.like("%" + keywords + "%")).order_by(
            Travels.addtime.desc()
        ).paginate(page=page, per_page=5)
    else:
        page_data = Travels.query.order_by(
            Travels.addtime.desc()
        ).paginate(page=page, per_page=5)
    return render_template("admin/travels_list.html", page_data=page_data, year=datetime.now().year)


@admin.route("/travels/edit/<int:id>/", methods=["GET", "POST"])
@admin_login
def travels_edit(id=None):
    """
    编辑游记
    """
    form = TravelsForm()
    form.scenic_id.choices = [(v.id, v.title) for v in Scenic.query.all()]
    form.submit.label.text = "修改"
    travels = Travels.query.get_or_404(int(id))
    if request.method == "GET":
        form.scenic_id.data = travels.scenic_id
        form.content.data = travels.content
    if form.validate_on_submit():
        data = form.data
        travels_count = Travels.query.filter_by(title=data["title"]).count()
        # 判断是否有重复数据
        if travels_count == 1 and travels.title != data["title"]:
            flash("游记已经存在！", "err")
            return redirect(url_for('admin.travels_edit', id=id))

        travels.title = data["title"]
        travels.scenic_id = data["scenic_id"]
        travels.author = data["author"]
        travels.content = data["content"]

        db.session.add(travels)
        db.session.commit()
        flash("修改景区成功！", "ok")
        return redirect(url_for('admin.travels_edit', id=id))
    return render_template("admin/travels_edit.html", form=form, travels=travels, year=datetime.now().year)


@admin.route("/travels/del/<int:id>/", methods=["GET"])
@admin_login
def travels_del(id=None):
    """
    景区删除
    """
    travels = Travels.query.get_or_404(id)
    db.session.delete(travels)
    db.session.commit()
    flash("游记删除成功", "ok")
    addOplog("删除游记" + travels.title)  # 添加日志
    return redirect(url_for('admin.travels_list', page=1))


@admin.route('/ckupload/', methods=['POST', 'OPTIONS'])
@admin_login
def ckupload():
    """CKEditor 文件上传"""
    error = ''
    url = ''
    callback = request.args.get("CKEditorFuncNum")

    if request.method == 'POST' and 'upload' in request.files:
        fileobj = request.files['upload']
        fname, fext = os.path.splitext(fileobj.filename)
        rnd_name = '%s%s' % (gen_rnd_filename(), fext)

        filepath = os.path.join(current_app.static_folder, 'uploads/ckeditor', rnd_name)
        print(filepath)
        # 检查路径是否存在，不存在则创建
        dirname = os.path.dirname(filepath)
        if not os.path.exists(dirname):
            try:
                os.makedirs(dirname)
            except:
                error = 'ERROR_CREATE_DIR'
        elif not os.access(dirname, os.W_OK):
            error = 'ERROR_DIR_NOT_WRITEABLE'

        if not error:
            fileobj.save(filepath)
            url = url_for('static', filename='%s/%s' % ('uploads/ckeditor', rnd_name))
    else:
        error = 'post error'

    res = """<script type="text/javascript">
  window.parent.CKEDITOR.tools.callFunction(%s, '%s', '%s');
</script>""" % (callback, url, error)

    response = make_response(res)
    response.headers["Content-Type"] = "text/html"
    return response


from flask.json import jsonify
from random import randrange
from pyecharts.charts import Bar, Pie, Line, Timeline
from pyecharts import options as opts


def bar_base() -> Bar:
    c = (
        Bar()
        .add_xaxis(["用电管理", "电表", "浓度", "压力", "急停开关", "安防雷达"])
        .add_yaxis("报警", [randrange(0, 100) for _ in range(6)])
        .set_global_opts(title_opts=opts.TitleOpts(title="设备报警柱形图", subtitle="报警次数"))
    )
    return c


xaxis = []
yaxis = []
i = 10


def get_xaxis():
    global xaxis
    if xaxis is None or len(xaxis) == 0:
        xaxis = ["{}".format(i) for i in range(10)]
    else:
        global i
        c = len(xaxis)
        del xaxis[c * -1]

        xaxis.append(i)

        i = i + 1
    print(xaxis)
    return xaxis


def get_yaxis():
    global yaxis
    if yaxis is None or len(yaxis) == 0:
        yaxis = [randrange(50, 80) for _ in range(10)]
    else:
        i = len(xaxis)
        del yaxis[i * -1]
        yaxis.append(randrange(50, 80))
    print(yaxis)
    return yaxis


def line_base() -> Line:
    line = (
        Line()
        .add_xaxis(get_xaxis())
        .add_yaxis(
            series_name="",
            y_axis=get_yaxis(),
            is_smooth=True,
            label_opts=opts.LabelOpts(is_show=False),
        )
        .set_global_opts(
            title_opts=opts.TitleOpts(title="动态数据"),
            xaxis_opts=opts.AxisOpts(type_="value", min_=xaxis[0]),
            yaxis_opts=opts.AxisOpts(type_="value"),
        )
    )
    return line


@admin.route("/data/forms/")
@admin_login
def data_forms():
    return render_template("admin/line_charts.html", s_url="http://127.0.0.1:5000/")


@admin.route("/lineChart")
def get_line_chart():
    c = line_base()
    return c.dump_options_with_quotes()


idx = 9


@admin.route("/getDynamicData")
def update_dynamic_data():
    list = app.api.stack_func.get_stack()
    # print(type(list))
    # print(list)
    return list


@admin.route("/barChart")
def get_bar_chart():
    c = bar_base()
    return c.dump_options_with_quotes()


def get_alarm_statistics(start_time, end_time):
    # pd = Alarm.query.join(
    #     Device
    # ).join(
    #     DeviceType
    # ).filter(
    #     Alarm.device_id == Device.id
    # ).filter(
    #     Device.devicetype_id == DeviceType.type
    # ).filter(
    #     datetime.strptime(start_time, "%Y-%m-%d %H:%M") < Alarm.addtime
    # ).filter(
    #     Alarm.addtime < datetime.strptime(end_time, "%Y-%m-%d %H:%M")
    # ).order_by(
    #     Device.devicetype_id.asc()
    # ).group_by(
    #     DeviceType.type
    # ).all()

    from sqlalchemy import text
    sql = text(
        f"SELECT count(a.id) as c, dt.`name` as n FROM alarm as a, device as d, devicetype as dt WHERE a.addtime>'{start_time}' \
        and a.addtime<'{end_time}'  AND a.device_id=d.id and d.devicetype_id=dt.type \
        GROUP BY dt.type ORDER BY c desc")

    res = db.session.execute(sql).fetchall()

    for r in res:
        print(r)

    return res


def alarm_bar_base(alarm, st, et) -> Bar:
    # devicetype = DeviceType.query.all()

    alarm_name = []
    alarm_count = []
    for a in alarm:
        alarm_name.append(a[1])
        alarm_count.append(a[0])

    # for dt in devicetype:
    #     if dt.name in alarm_name:
    #         continue
    #     else:
    #         alarm_name.append(dt.name)
    #         alarm_count.append(0)

    c = (
        Bar(

        )
        .add_xaxis(
            alarm_name
        )
        .add_yaxis(
            "报警", alarm_count,
            bar_max_width=40,
            bar_min_width=10,
            # color="indianred"
            background_style=["red"],
        )
        # .add_yaxis(
        #     "预警", alarm_count,
        #     bar_max_width=40,
        #     bar_min_width=20,
        # )
        .reversal_axis()
        .set_series_opts(label_opts=opts.LabelOpts(position="right"))

        .set_global_opts(
            title_opts=opts.TitleOpts(title="设备报警柱形图", subtitle="报警次数", ),
            legend_opts=opts.LegendOpts(
                orient="center",  # 水平排布
            ),

        )
    )
    return c


@admin.route("getAlarmStatisticsBar", methods=["GET"])
def get_alarm_statistics_bar():
    st = request.args.get('startTime').replace("T", " ")
    et = request.args.get('endTime').replace("T", " ")
    alarm = get_alarm_statistics(st, et)
    c = alarm_bar_base(alarm, st, et)
    return c.dump_options_with_quotes()


from pyecharts.faker import Faker


def alarm_pie_base(alarm) -> Pie:
    alarm_name = []
    alarm_count = []
    for a in alarm:
        alarm_name.append(a[1])
        alarm_count.append(a[0])
    c = (
        Pie()
        .add(
            "设备报警饼状图",
            [list(z) for z in zip(alarm_name, alarm_count)],
            radius=["40%", "75%"],
        )
        .set_global_opts(
            title_opts=opts.TitleOpts(title="设备报警饼状图", subtitle="报警次数"),
            # legend_opts=opts.LegendOpts(orient="vertical", pos_top="15%", pos_left="2%"),
        )
        .set_series_opts(label_opts=opts.LabelOpts(formatter="{b}: {c}"))
    )

    return c


@admin.route("getAlarmStatisticsPie", methods=["GET"])
def get_alarm_statistics_pie():
    st = request.args.get('startTime').replace("T", " ")
    et = request.args.get('endTime').replace("T", " ")
    alarm = get_alarm_statistics(st, et)
    c = alarm_pie_base(alarm)
    return c.dump_options_with_quotes()


@admin.route("gaugeChart", methods=["GET"])
def gauge_chart():
    from pyecharts.charts import Gauge

    c = (
        Gauge(init_opts=opts.InitOpts(width="150px", height="150px"))
        .add(
            "电流图",
            [("漏电流(mA)", 155.5), ],
            max_=1000,
            split_number=5,
            axisline_opts=opts.AxisLineOpts(
                linestyle_opts=opts.LineStyleOpts(
                    color=[(0.3, "#67e0e3"), (0.7, "#37a2da"), (1, "#fd666d")], width=30
                )
            ),
            detail_label_opts=opts.LabelOpts(formatter="{value}"),

        )
        .set_global_opts(
            title_opts=opts.TitleOpts(title=""),
            legend_opts=opts.LegendOpts(is_show=False),
        )

    )

    return c.dump_options_with_quotes()


@admin.route("pieChartV", methods=["GET"])
def get_pie_chartV():
    from pyecharts.charts import Pie
    from pyecharts.faker import Faker

    pcm = get_stack("PCM")
    UA = 0
    UB = 0
    UC = 0
    if len(pcm) > 0:
        UA = pcm[0].UA
        UB = pcm[0].UB
        UC = pcm[0].UC
    c = (
        Pie()
        .add(
            "电压",
            # [["A相", "B相", "C相"], [222.3, 220.9, 230.1]],
            [list(z) for z in zip(["A相", "B相", "C相"], [UA, UB, UC])],
            radius=["40%", "75%"],
        )
        .set_global_opts(
            title_opts=opts.TitleOpts(title="电压-V"),
            legend_opts=opts.LegendOpts(orient="vertical", pos_top="15%", pos_left="2%"),
        )
        .set_series_opts(label_opts=opts.LabelOpts(formatter="{b}{c}V"))

    )
    return c.dump_options_with_quotes()


@admin.route("pieChartA", methods=["GET"])
def get_pie_chartA():
    pcm = get_stack("PCM")
    IA = 0
    IB = 0
    IC = 0
    if len(pcm) > 0:
        IA = pcm[0].IA
        IB = pcm[0].IB
        IC = pcm[0].IC
    c = (
        Pie()
        .add(
            "电流",
            [list(z) for z in zip(["A相", "B相", "C相"], [IA, IB, IC])],
            radius=["40%", "75%"],
        )
        .set_global_opts(
            title_opts=opts.TitleOpts(title="电流-A"),
            legend_opts=opts.LegendOpts(orient="vertical", pos_top="15%", pos_left="2%"),
        )
        .set_series_opts(label_opts=opts.LabelOpts(formatter="{b}{c}A"))

    )
    return c.dump_options_with_quotes()


@admin.route("liquidChart", methods=["GET"])
def get_liquid_chart():
    from pyecharts.charts import Liquid

    c = (
        Liquid(init_opts=opts.InitOpts())
        .add("lq", [0.6, 0.7, 0.8], is_outline_show=True)
        .set_global_opts(title_opts=opts.TitleOpts(title="Liquid-无边框"))

    )

    return c.dump_options_with_quotes()