摘要：和都是很好用的插件，然而當它們結合到一起后，就不是那么美妙了。當然了寫一個完整的擴展還是很麻煩的。可以看官方擴展的源碼。。。

Flask-WTF和Flask-SQLAlchemy都是很好用的插件，然而當它們結合到一起后，就不是那么美妙了。

在models.py中定義了一個Article、Category和Tag類：

class Article(db.Model):
    """定義文章"""

    __tablename__ = "articles"
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(128), unique=True, index=True)
    # 保存md格式的文本
    content = db.Column(db.Text)
    # 保存html格式的文本
    content_html = db.Column(db.Text)
    # 文章分類
    category_id = db.Column(db.Integer, db.ForeignKey("categories.id"))
    # 文章標簽
    tags = db.relationship(
        "Tag", secondary="article_tag_ref", backref="articles")
class Category(db.Model):
    """文章分類"""

    __tablename__ = "categories"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), unique=True)
    articles = db.relationship("Article", backref="category", lazy="dynamic")

class Tag(db.Model):
    """文章標簽"""

    __tablename__ = "tags"
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(128), unique=True)

# 文章和標簽的映射表 ，多對多關系
article_tag_ref = db.Table("article_tag_ref",
                           db.Column("article_id", db.Integer,
                                     db.ForeignKey("articles.id")),
                           db.Column("tag_id",  db.Integer,
                                     db.ForeignKey("tags.id"))
                           )

然后在forms.py中定義一個ArticleForm表單

class ArticleForm(Form):

    title = StringField(u"標題", validators=[Required()])
    category = QuerySelectField(u"分類", query_factory=getUserFactory(["id", "name"]), get_label="name")
    tags = StringField(u"標簽", validators=[Required()])
    content = PageDownField(u"正文", validators=[Required()])
    submit = SubmitField(u"發布")

此時在處理表單的時候可以這樣：

form = ArticleForm()
if form.validate_on_submit():
    article = Article(title=from.data.title, content=form.data.content,category=form.category.data)
    ...

等等，這樣怎么處理form.data.tags？只有像下面這樣寫了：

"""
:param tags:
    標簽列表，如[u"測試",u"Flask"]
"""
def str_to_obj(tags):
    r = []
    for tag in tags:
        tag_obj = Tag.query.filter_by(name=tag).first()
        if tag_obj is None:
            tag_obj = Tag(name=tag)
        r.append(tag_obj)
    return r

然后在上面的代碼中加入：

 form = ArticleForm()
if form.validate_on_submit():
    article = Article(title=from.data.title, content=form.data.content, category=form.category.data, tags=str_to_obj(form.data.tags))   

這樣是不是很難看，像form.data.category就是一個對象，為撒到form.data.tags了就不是了，還要專門寫一個函數來坐一個轉換？這個時候就有必要擴展WTForms中的表單了。
　

閱讀WTForms文檔，關于如何創建一個TagListField，貼一下代碼：

class TagListField(Field):
    widget = TextInput()

    def _value(self):
        if self.data:
            return u", ".join(self.data)
        else:
            return u""

    def process_formdata(self, valuelist):
        if valuelist:
            self.data = [x.strip() for x in valuelist[0].split(",")]
        else:
            self.data = []

簡單了看了一下WTForms源碼，大致搞清楚了上面代碼兩個方法的作用：

_value The _value method is called by the TextInput widget to provide the value that is displayed in the form. 在初始化表單的時候，就是調用這個方法在表單中渲染數據

process_formdata 表單提交時，處理該字段的數據。

根據上面的代碼，將TagListField中的字符串轉為models.py中定義的Tag對象即可：

class TagListField(Field):
    widget = TextInput()

    def __init__(self, label=None, validators=None,
                 **kwargs):
        super(TagListField, self).__init__(label, validators, **kwargs)

    def _value(self):
        if self.data:
            r = u""
            for obj in self.data:
                r += self.obj_to_str(obj)
            return u""
        else:
            return u""

    def process_formdata(self, valuelist):
        print "process_formdata.."
        print valuelist
        if valuelist:
            tags = self._remove_duplicates([x.strip() for x in valuelist[0].split(",")])
            self.data = [self.str_to_obj(tag) for tag in tags]
        else:
            self.data = None

    def pre_validate(self, form):
        pass

    @classmethod
    def _remove_duplicates(cls, seq):
        """去重"""
        d = {}
        for item in seq:
            if item.lower() not in d:
                d[item.lower()] = True
                yield item

    @classmethod
    def str_to_obj(cls, tag):
        """將字符串轉換位obj對象"""
        tag_obj = Tag.query.filter_by(name=tag).first()
        if tag_obj is None:
            tag_obj = Tag(name=tag)
        return tag_obj

    @classmethod
    def obj_to_str(cls, obj):
        """將對象轉換為字符串"""
        if obj:
            return obj.name
        else:
            return u""

主要就是在process_formdata這一步處理表單的數據，將字符串轉換為需要的數據。最終就可以在forms.py中這樣定義表單了：

...
class ArticleForm(Form):
    """編輯文章表單"""

    title = StringField(u"標題", validators=[Required()])
    category = QuerySelectField(u"分類", query_factory=get_category_factory(["id", "name"]), get_label="name")
    tags = TagListField(u"標簽", validators=[Required()])
    content = PageDownField(u"正文", validators=[Required()])
    submit = SubmitField(u"發布")
...

在views.py中處理表單就很方便了：

def edit_article():
    """編輯文章"""

    form = ArticleForm()
    if form.validate_on_submit():
        article = Article(title=form.title.data, content=form.content.data)
        article.tags = form.tags.data
        article.category = form.category.data
        try:
            db.session.add(article)
            db.session.commit()
        except:
            db.session.rollback()
    return render_template("dashboard/edit.html", form=form)

代碼是不是很簡潔了？^_^。。。

當然了寫一個完整的WTForms擴展還是很麻煩的。這里只是剛剛入門。可以看官方擴展QuerySelectField的源碼。。。