xbackend/api/api_v1/endpoints/data_auth.py

import json

import pymongo
from bson import ObjectId
from fastapi import APIRouter, Depends, Request
from fastapi.encoders import jsonable_encoder
from motor.motor_asyncio import AsyncIOMotorDatabase
from redis import Redis

import crud, schemas
from core.config import settings
from core.security import get_password_hash

from db import get_database
from api import deps
from db.ckdb import CKDrive, get_ck_db
from db.redisdb import get_redis_pool, RedisDrive
from utils import casbin_enforcer

router = APIRouter()


@router.post('/add_data_auth')
async def add_data_auth(request: Request,
                        data_id: schemas.DataAuthCreate,
                        game: str = Depends(deps.get_game_project),
                        db: AsyncIOMotorDatabase = Depends(get_database),
                        current_user: schemas.UserDB = Depends(deps.get_current_user)
                        ) -> schemas.Msg:
    """创建数据权限"""
    await crud.data_auth.create(db, data_id, game)
    return schemas.Msg(code=0, msg='ok', data=data_id)


@router.post('/edit_data_auth')
async def edit_data_auth(request: Request,
                         data_id: schemas.DataAuthEdit,
                         game: str,
                         db: AsyncIOMotorDatabase = Depends(get_database),
                         current_user: schemas.UserDB = Depends(deps.get_current_user)
                         ) -> schemas.Msg:
    """修改数据权限"""
    await crud.data_auth.edit_data_auth(db, data_id)
    return schemas.Msg(code=0, msg='ok', data=data_id)


@router.get('/all_event')
async def all_event(request: Request,
                    game: str,
                    ck: CKDrive = Depends(get_ck_db),
                    db: AsyncIOMotorDatabase = Depends(get_database),
                    current_user: schemas.UserDB = Depends(deps.get_current_user)
                    ) -> schemas.Msg:
    """获取所有事件"""
    values = await ck.distinct(game, 'event', '#event_name')
    values.sort()
    return schemas.Msg(code=0, msg='ok', data=values)


@router.get("/list")
async def data_authority(request: Request,
                         game: str,
                         db: AsyncIOMotorDatabase = Depends(get_database),
                         ck: CKDrive = Depends(get_ck_db),
                         current_user: schemas.UserDB = Depends(deps.get_current_user)
                         ) -> schemas.Msg:
    """获取前项目数据权限"""
    total_event = await ck.distinct_count(game, 'event', '#event_name')
    data = await crud.data_auth.get_game_data_auth(db, game)
    for item in data:
        item['id'] = str(item['_id'])
        del item['_id']
        item['data_range'] = f'{len(item["data"])}/{total_event}'

    data = jsonable_encoder(data)
    return schemas.Msg(code=0, msg='ok', data=data)


@router.get("/my_event")
async def my_event(request: Request,
                   game: str,
                   db: AsyncIOMotorDatabase = Depends(get_database),
                   rdb: RedisDrive = Depends(get_redis_pool),
                   ck: CKDrive = Depends(get_ck_db),
                   current_user: schemas.UserDB = Depends(deps.get_current_user)
                   ) -> schemas.Msg:
    """获取自己的事件权限"""

    # data_auth_id = await crud.authority.get_data_auth_id(db, game, request.user.username)
    data_auth_id = await crud.authority.get_data_auth_id(db, game, 'wuhao')
    my_data_auth = await crud.data_auth.get(db, ObjectId(data_auth_id))

    all_filed = await rdb.get(f'{game}_event')
    all_filed = json.loads(all_filed)
    data_attr = await crud.data_attr.find_many(db, game=game, cat='event')
    data_attr = {item['name']: item for item in data_attr}

    if not my_data_auth:
        return schemas.Msg(code=0, msg='ok', data=[])
    key_prefix = f'{game}_event_'

    event_dict = await rdb.smembers_keys(*my_data_auth['data'], prefix=key_prefix)
    event = []

    group_by = [{
        'id': item,
        'data_type': settings.CK_TYPE_DICT.get(all_filed.get(item)),
        'title': data_attr.get(item, {}).get('show_name') or item,
        'category': settings.CK_FILTER.get(settings.CK_TYPE_DICT.get(all_filed.get(item))) or []
    } for item in all_filed]

    deserialization = {
        'event_attr': {},
        'event_filter': {}
    }
    for k, v in event_dict.items():
        event_attr = [{
            'id': '*',
            'data_type': None,
            'analysis': 'total_count',
            'title': '总次数',
            'category': []
        },
            {
                'id': '*',
                'analysis': 'touch_user_count',
                'data_type': None,
                'title': '触发用户数',
                'category': []
            },
            {
                'id': '*',
                'analysis': 'touch_user_avg',
                'data_type': None,
                'title': '人均次数',
                'category': []
            }

        ]
        event_filter = []
        for item in sorted(v):
            data_type = settings.CK_TYPE_DICT.get(all_filed.get(item))
            title = data_attr.get(item, {}).get('show_name') or item
            event_attr.append(
                {
                    'id': item,
                    'data_type': data_type,
                    'title': title,
                    'category': settings.CK_OPERATOR.get(data_type) or []
                }
            )

            event_filter.append({
                'id': item,
                'data_type': data_type,
                'title': title,
                'category': settings.CK_FILTER.get(data_type) or []
            })

        deserialization['event_attr'][k] = [{'id': 'event', 'title': '事件属性', 'category': event_attr}]
        deserialization['event_filter'][k] = [{'id': 'event', 'title': '事件属性', 'category': event_filter}]

        event.append({
            'event_name': k,
            'event_attr': [{'id': 'event', 'title': '事件属性', 'category': event_attr}],
            'event_filter': [{'id': 'event', 'title': '事件属性', 'category': event_filter}],
        }
        )

    res = {
        'operator': settings.CK_OPERATOR,
        'filter': settings.CK_FILTER,
        'deserialization': deserialization,

        'analysis': [{'id': 'event',
                      'title': '默认分组',
                      'category': event
                      }],
        'group_by': [{
            'id': 'event',
            'title': '默认分组',
            'category': group_by
        }]
    }

    return schemas.Msg(code=0, msg='ok', data=res)