aiohttp 增删该查通用代码块

import time

from aiohttp import web

from bson.objectid import ObjectId


class DateMethod():
    def __init__(self):
        self._collection = None
        self._pop_field_data = []
        self.created_at = time.strftime("%Y-%m-%d %H-%M-%S", time.localtime())
        self._parameter_list = None

    @property
    def put_collection(self):
        return self._collection

    @put_collection.setter
    def put_collection(self, collection):
        self._collection = collection

    @property
    def pop_field(self):
        return self._pop_field_data

    @pop_field.setter
    def pop_field(self, pop_data):
        # 删除字段
        self._pop_field_data = pop_data

    @property
    def put_parameter_list(self):
        return self._parameter_list

    @put_parameter_list.setter
    def put_parameter_list(self, parameter_list):
        self._parameter_list = parameter_list

    @classmethod
    def get_id(self, x):
        x['id'] = str(x.pop('_id'))
        return x


class ParameterMethod(DateMethod):
    def __init__(self):
        self.parameter_list = None
        super().__init__()

    def return_response(self, status, error=None, data=None, **kwargs):
        where = {"status": status, "error": error}
        if data:
            where.update({"data": data})
            where.update(kwargs)
        return web.json_response(where)

    def parameter_verification(self, form_data, **kwargs):
        # 校验参数必有字段
        if ([key for key, value in form_data.items() if key not in self.parameter_list]):
            return self.return_response(False, error="parameter not exist.")
        # 必传参数，没传
        elif [value for key, value in kwargs.items() if not value]:
            return self.return_response(False, error="Required_parameter_not_transmitted")
        else:
            return None


class MongoMethod(ParameterMethod):
    def __init__(self, request):
        super().__init__()
        self.request = request
        self.db = self.request.app['db']

    async def get_count(self, number, where=None):
        # 查询数量
        if not where:
            where = {}
        data_count = await self.db[self._collection].count_documents(where)
        if number:
            number = int(number)
        else:
            number = data_count
        return number

    async def find_one(self, where={}):
        # 查询单个接口
        data = await self.db[self._collection].find_one(where)
        if data:
            data = self.get_id(data)
            if self._pop_field_data:
                [data.pop(key) for key in self._pop_field_data if key]
            return self.return_response(True, data=custom_data)
        return self.return_response(False)

    async def insert_data(self, where):
        # 创建数据
        data = await self.db[self._collection].find_one(where, {'_id': 0})
        if data:
            return self.return_response(True, data=data)
        where.update({"created_at": self.created_at})
        insert_data = await self.db[self._collection].insert_one(where)
        where = self.get_id(where)
        if self._pop_field_data:
            [where.pop(key) for key in self._pop_field_data if key]
        id = str(insert_data.inserted_id)
        if id:
            return self.return_response(True, data=where)
        else:
            return self.return_response(False)

    async def put_one_data(self, where, update_date):
        # 修改数据
        data = await self.db[self._collection].find_one_and_update(where, {"$set": update_date})
        data = self.get_id(data)
        if data:
            if self._pop_field_data:
                [data.pop(key) for key in self._pop_field_data if key]
            data.update(update_date)
            return self.return_response(True, data=custom_data)
        return self.return_response(False)

    async def delete_one_data(self, id):
        # 删除数据
        if id:
            delete_data = await self.db[self._collection].find_one_and_delete({"_id": ObjectId(id)})
            if delete_data:
                return self.return_response(True, data={"id": id})
        return self.return_response(False)

    async def get_data_list(self, created_at, where={}, page=1, number=None, query_fields={}):
        number = await self.get_count(number, where)
        data = await self.db[self._collection].find(where, query_fields).sort([(created_at, -1)]).skip(
            (page - 1) * number).limit(
            number).to_list(length=number)
        if data:
            return self.return_response(True, data=data, count=number)
        return self.return_response(False)