# !/usr/bin/env python3
# -*- encoding : utf-8 -*-
# @Filename    : role.py
# @Software    : VSCode
# @Datetime    : 2021/11/15 21:25:46
# @Author      : leo liu
# @Version     : 1.0
# @Description :

from loguru import logger
from pydantic.types import conint
from sqlalchemy import func, desc
from sqlalchemy.orm import Session
from sqlalchemy.sql.expression import and_, or_

from extensions.curd_base import CRUDBase
from models import Role, user_role, role_menu
from .menu import crud_menu
from ..schemas import role_schema


class CRUDRole(CRUDBase[Role, role_schema.RoleCreate, role_schema.RoleUpdate]):
    @staticmethod
    def query_all(db: Session, *, col_val: str = "", is_delete: int = 0, page: int = 0, page_size: conint(le=50) = 20, order_by: str = "id", is_desc: bool = False) -> dict:
        """
        查询角色列表
        :param db:
        :param col_val: 输入模糊查询参数值，对应username、nickname和email
        :param is_delete: 输入参数值，是否逻辑删除
        :param page: 输入参数值，分页页号，为0时不分页
        :param page_size: 输入参数值，分页页宽，page=0时无效
        :param order_by: 输入参数值，排序字段
        :param is_desc: 排序顺序，true为asc，false为desc
        :return: Role字典
        """
        temp_page = (page - 1) * page_size
        search = None
        order_type = None

        # 处理多个字段的模糊查询：name
        if col_val:
            search = and_(Role.is_delete == is_delete, or_(Role.name.like('%' + col_val + "%"), Role.title.like('%' + col_val + "%")))
        else:
            search = Role.is_delete == is_delete

        # 处理排序方式
        # 利用属性名反射类属性
        if is_desc:
            order_type = desc(Role.getAttrFromName(Role, order_by))
        else:
            order_type = Role.getAttrFromName(Role, order_by)

        # 查询数量
        total = db.query(func.count(Role.role_id)).filter(search).scalar()

        # 查询结果集
        if page > 0:
            query_obj = db.query(Role).filter(search).order_by(order_type).offset(temp_page).limit(page_size).all()
        else:
            query_obj = db.query(Role).filter(search).order_by(order_type).all()

        items = [{
            "id": obj.id,
            "role_id": obj.role_id,
            "name": obj.name,
            "title": obj.title,
            "menus": obj.menus,
            "create_time": obj.create_time,
            "is_delete": obj.is_delete,
            "update_time": obj.update_time
        } for obj in query_obj]

        return {
            "items": items,
            "total": total
        }

    @staticmethod
    def get_by_id(db: Session, *, role_id: str) -> Role:
        return db.query(Role).filter(Role.role_id == role_id).first()

    @staticmethod
    def is_exist(db: Session, role_in: role_schema.BaseRole) -> bool:
        role = db.query(Role).filter(or_(
            Role.role_id == role_in.role_id,
            Role.name == role_in.name,
            Role.title == role_in.title
        )).first()

        if role:
            return True
        else:
            return False

    @staticmethod
    def update(db: Session, *, obj_in: role_schema.RoleUpdate) -> Role:
        db_obj = db.query(Role).filter(Role.role_id == obj_in.role_id).first()

        if db_obj:
            if (obj_in.title):
                db_obj.title = obj_in.title

            if (obj_in.menus):
                db_obj.menus.clear()

                for m in obj_in.menus:
                    menu = crud_menu.get_by_path(db, path=m['path'])

                    if (menu):
                        db_obj.menus.append(menu)

            db_obj.is_delete = obj_in.is_delete

            if (obj_in.is_delete):
                db.query(user_role).filter(user_role.c.role_id == db_obj.role_id).delete()
                db.query(role_menu).filter(role_menu.c.role_id == db_obj.role_id).delete()

            db.commit()
            db.refresh(db_obj)

        return db_obj

crud_role = CRUDRole(Role)