flask框架：编写搜索功能

青旅半醒 2022-12-22 09:53 230阅读 0赞

# 前言 #

搜索功能实现

--------------------

# 代码实现 #

*  form表单

# -*- coding: utf-8 -*-
    # @Author  : ZhaoCunWei
    # @Time    : 2020/11/3 5:41 下午
    # @Function:
    
    from wtforms import  StringField, IntegerField
    from wtforms.validators import DataRequired, length, Email, Regexp, ValidationError
    
    from app.libs.enums import ClientTypeEnum
    from app.api.validators.base import BaseForm as Form
    
    class ClientForm(Form):
        account = StringField(validators=[DataRequired(message='不允许为空'), length(min=5, max=32)])
        secret = StringField()
        type = IntegerField(validators=[DataRequired()])
    
        def validate_type(self, value):
            try:
                client = ClientTypeEnum(value.data)
            except ValueError as e:
                raise e
            self.type.data = client
    
    
    class UserEmailForm(ClientForm):
        account = StringField(validators=[
            Email(message='invalidate email')
        ])
        secret = StringField(validators=[
            DataRequired(),
            Regexp(r'^[A-ZA-Z0-9_*&$#@] {6,22}$')
        ])
        nickname = StringField(validators=[DataRequired(),
                                           length(min=2, max=22)])
    
        def validate_account(self, value):
            from app.models.user import User
            if User.query.filter_by(email=value.data).first():
                raise ValidationError()
    
    class BookSearchForm(Form):
        q = StringField(validators=[DataRequired()])

*  model

# -*- coding: utf-8 -*-
    # @Author  : ZhaoCunWei
    # @Time    : 2020/11/19 5:37 下午
    # @Function:
    
    from sqlalchemy import Column, String, Integer, orm
    
    from app.models.base import Base
    
    
    class Book(Base):
        id = Column(Integer, primary_key=True, autoincrement=True)
        title = Column(String(50), nullable=False)
        author = Column(String(30), default='未名')
        binding = Column(String(20))
        publisher = Column(String(50))
        price = Column(String(20))
        pages = Column(Integer)
        pubdate = Column(String(20))
        isbn = Column(String(15), nullable=False, unique=True)
        summary = Column(String(1000))
        image = Column(String(50))
    
        @orm.reconstructor
        def __init__(self):
            self.fields = ['id', 'title', 'author', 'binding',
                           'publisher',
                           'price', 'pages', 'pubdate', 'isbn',
                           'summary',
                           'image']

*  book-API

# -*- coding: utf-8 -*-
    # @Author  : ZhaoCunWei
    # @Time    : 2020/11/3 2:33 下午
    # @Function:
    from app.api.validators.forms import BookSearchForm
    from app.libs.redprint import Redprint
    from app.models.book import Book
    from flask import jsonify
    from sqlalchemy import or_
    
    api = Redprint('book')
    
    
    @api.route('/get')
    def get_book():
        return 'get book'
    
    
    @api.route('/create')
    def create_book():
        return 'create book'
    
    
    
    
    @api.route('/search')
    def search():
        form = BookSearchForm().validate_for_api()
        q = '%' + form.q.data + '%'
        # book = Book()
        # 元类 ORM
        books = Book.query.filter(
            or_(Book.title.like(q), Book.publisher.like(q))).all()
            # 过滤掉我们不想要的数据
        books = [book.hide('summary') for book in books]
        return jsonify(books)
    
    # 跳转详情页面
    @api.route('/<isbn>/detail')
    def detail(isbn):
        book = Book.query.filter_by(isbn=isbn).first_or_404()
        return jsonify(book)

*  隐藏多个字段  
    api方法：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzcwOTEz_size_16_color_FFFFFF_t_70_pic_center]
 *  模型  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzcwOTEz_size_16_color_FFFFFF_t_70_pic_center 1]
 *  抽成公共方法：  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzcwOTEz_size_16_color_FFFFFF_t_70_pic_center 2]

from datetime import datetime
    
    from flask_sqlalchemy import SQLAlchemy as _SQLAlchemy, BaseQuery
    from sqlalchemy import inspect, Column, Integer, SmallInteger, orm
    from contextlib import contextmanager
    
    
    class SQLAlchemy(_SQLAlchemy):
        @contextmanager
        def auto_commit(self):
            try:
                yield
                self.session.commit()
            except Exception as e:
                db.session.rollback()
                raise e
    
    
    class Query(BaseQuery):
        def filter_by(self, **kwargs):
            if 'status' not in kwargs.keys():
                kwargs['status'] = 1
            return super(Query, self).filter_by(**kwargs)
    
        def get_or_404(self, ident):
            rv = self.get(ident)
            if not rv:
                raise NotFound()
            return rv
    
        def first_or_404(self):
            rv = self.first()
            if not rv:
                raise NotFound()
            return rv
    
    
    db = SQLAlchemy(query_class=Query)
    
    
    class Base(db.Model):
        __abstract__ = True
        create_time = Column(Integer)
        status = Column(SmallInteger, default=1)
    
        def __init__(self):
            self.create_time = int(datetime.now().timestamp())
    
        def __getitem__(self, item):
            return getattr(self, item)
    
        @property
        def create_datetime(self):
            if self.create_time:
                return datetime.fromtimestamp(self.create_time)
            else:
                return None
    
        def set_attrs(self, attrs_dict):
            for key, value in attrs_dict.items():
                if hasattr(self, key) and key != 'id':
                    setattr(self, key, value)
    
        def delete(self):
            self.status = 0
    
        def keys(self):
            return self.fields
    
        def hide(self, *keys):
            for key in keys:
                self.fields.remove(key)
            return self
    
        def append(self, *keys):
            for key in keys:
                self.fields.append(key)
            return self
    
    
    class MixinJSONSerializer:
        @orm.reconstructor
        def init_on_load(self):
            self._fields = []
            # self._include = []
            self._exclude = []
    
            self._set_fields()
            self.__prune_fields()
    
        def _set_fields(self):
            pass
    
        def __prune_fields(self):
            columns = inspect(self.__class__).columns
            if not self._fields:
                all_columns = set(columns.keys())
                self._fields = list(all_columns - set(self._exclude))
    
        def hide(self, *args):
            for key in args:
                self._fields.remove(key)
            return self
    
        def keys(self):
            return self._fields
    
        def __getitem__(self, key):
            return getattr(self, key)

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzcwOTEz_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/6accaab00894449b9c6fe9ba6d1fb687.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzcwOTEz_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221120/b60cffffd43b4c42a2ce58a283f8587e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyMzcwOTEz_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221120/ff7e6fee9dbb4dc4a337c916a7da7f52.png