flask 开发接口测试平台

　　数据库，forms  views  视图，

　　数据库如下：

  1. # encoding: utf-8
  2. '''
  3. @author: lileilei
  4. @file: models.py
  5. @time: 2017/5/6 19:28
  6. '''
  7. from  app import  db
  8. import datetime
  9. from werkzeug.security import generate_password_hash,check_password_hash
  10. class User(db.Model):#用户表
  11.     uer_id=db.Column(db.Integer,primary_key=True,autoincrement=True)#用户id
  12.     user_name=db.Column(db.String(64))#用户名
  13.     password=db.Column(db.String(64))#用户密码
  14.     status=db.Column(db.Integer)
  15.     level=db.Column(db.Integer)
  16.     user_zhuce_date=db.Column(db.DateTime,default=datetime.datetime.now())#注册时间
  17.     user_zhuce_email=db.Column(db.String(64))#注册ip
  18.     user_iphone=db.Column(db.Integer)#手机号
  19.     user_qq=db.Column(db.Integer)#qq
  20.     def __repr__(self):
  21.         return '<User %r>' % self.user_name
  22.     def set_password(self, password):
  23.         self.password = generate_password_hash(password)
  24.     def check_password(self, password):
  25.         return check_password_hash(self.password, password)
  26. class Model(db.Model):#模块
  27.     model_id=db.Column(db.Integer,primary_key=True,autoincrement=True)
  28.     model_name = db.Column(db.String(256))
  29.     status = db.Column(db.Integer)
  30. class Interface(db.Model):#接口
  31.     interface_id=db.Column(db.Integer,primary_key=True,autoincrement=True)
  32.     model_id=db.Column(db.Integer,db.ForeignKey('model.model_id'))#对应模块的名字
  33.     interface_name=db.Column(db.String(64))#接口名字
  34.     interface_url=db.Column(db.String(1024))#接口地址
  35.     interface_methd=db.Column(db.String(64))#接口请求方式
  36.     request_exam=db.Column(db.String(4096))#请求
  37.     reposnese_exam=db.Column(db.String(4096))#返回
  38.     stasus=db.Column(db.Integer)#状态
  39.     def __repr__(self):
  40.         return '<Interface name is :%r>'%self.interface_name
  41. class Parameter(db.Model):
  42.     parameter_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
  43.     interface_id = db.Column(db.Integer, db.ForeignKey("interface.interface_id"))
  44.     parameter_type = db.Column(db.String(64))
  45.     parameter_group_id = db.Column(db.Integer)
  46.     parameter_name = db.Column(db.String(64))
  47.     necessary = db.Column(db.String(64))
  48.     type = db.Column(db.String(64))
  49.     default = db.Column(db.String(64))
  50.     remark = db.Column(db.String(64))
  51.     level = db.Column(db.String(64))

views 视图函数如下：

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. import sys
  4. from flask import render_template, redirect, session, url_for,flash,request
  5. from app import app
  6. from app import db
  7. from .models import Interface, Model, User, Parameter
  8. from .forms import LoginForm, ReguistForm,ModelForm, InterfaceForm, ParameterRequestForm, ParameterResponseForm, SubmitForm
  9. import datetime
  10. # 前台首页
  11. @app.route("/", methods=["GET", "POST"])
  12. @app.route("/index", methods=["GET", "POST"])
  13. def index():
  14.     return render_template("index.html")
  15. # 前台模块列表
  16. @app.route("/font", methods=["GET", "POST"])
  17. def front():
  18.     model_all = Model.query.all()
  19.     model_forms = []
  20.     for i in range(len(model_all)):
  21.         model_form = {"model_id": model_all[i].model_id,
  22.                       "model_name": model_all[i].model_name}
  23.         model_forms.append(model_form)
  24.     return render_template("front.html",
  25.                            model_forms=model_forms)
  26. # 前台接口列表
  27. @app.route("/front_model/<model_id>", methods=["GET", "POST"])
  28. def front_model(model_id):
  29.     model_one = Model.query.filter_by(model_id=model_id).first()
  30.     interface_model_all = Interface.query.filter_by(model_id=model_id).all()
  31.     interface_model_forms = []
  32.     for i in range(len(interface_model_all)):
  33.         interface_model_form = {"interface_id": interface_model_all[i].interface_id,
  34.                                 "interface_name": interface_model_all[i].interface_name,
  35.                                 "interface_url": interface_model_all[i].interface_url}
  36.         interface_model_forms.append(interface_model_form)
  37.     return render_template("front_model.html",
  38.                            model_id=model_id,
  39.                            model_one=model_one,
  40.                            interface_model_forms=interface_model_forms)
  41. g_parameter_request = []
  42. g_parameter_response = []
  43. # 前台接口详情
  44. @app.route("/front_interface/<model_id>&<interface_id>", methods=["GET", "POST"])
  45. def front_interface(model_id, interface_id):
  46.     global g_parameter_request, g_parameter_response
  47.     model_one = Model.query.filter_by(model_id=model_id).first()
  48.     interface_model_all = Interface.query.filter_by(model_id=model_id).all()
  49.     interface_model_one = Interface.query.filter_by(interface_id=interface_id).first()
  50.     interface_model_forms = []
  51.     for i in range(len(interface_model_all)):
  52.         interface_model_form = {"interface_id": interface_model_all[i].interface_id,
  53.                                 "interface_name": interface_model_all[i].interface_name,
  54.                                 "interface_url": interface_model_all[i].interface_url}
  55.         interface_model_forms.append(interface_model_form)
  56.     parameter_request_all = Parameter.query.filter_by(interface_id=interface_id, parameter_type=10).all()
  57.     parameter_request_forms = []
  58.     for i in range(len(parameter_request_all)):
  59.         parameter_request_form = {"parameter_id": parameter_request_all[i].parameter_id,
  60.                                   "parameter_name": parameter_request_all[i].parameter_name,
  61.                                   "necessary": parameter_request_all[i].necessary,
  62.                                   "type": parameter_request_all[i].type,
  63.                                   "default": parameter_request_all[i].default,
  64.                                   "remark": parameter_request_all[i].remark,
  65.                                   "parameter_group_id": parameter_request_all[i].parameter_group_id,
  66.                                   "level": parameter_request_all[i].level}
  67.         parameter_request_forms.append(parameter_request_form)
  68.     parameter_response_all = Parameter.query.filter_by(interface_id=interface_id, parameter_type=20).all()
  69.     parameter_response_forms = []
  70.     for i in range(len(parameter_response_all)):
  71.         parameter_response_form = {"parameter_id": parameter_response_all[i].parameter_id,
  72.                                    "parameter_name": parameter_response_all[i].parameter_name,
  73.                                    "necessary": parameter_response_all[i].necessary,
  74.                                    "type": parameter_response_all[i].type,
  75.                                    "default": parameter_response_all[i].default,
  76.                                    "remark": parameter_response_all[i].remark,
  77.                                    "parameter_group_id": parameter_response_all[i].parameter_group_id,
  78.                                    "level": parameter_response_all[i].level}
  79.         parameter_response_forms.append(parameter_response_form)
  80.     g_parameter_request = []    # 全局变量、清空列表数据
  81.     g_parameter_response = []   # 全局变量、清空列表数据
  82.     n_parameter_request(parameter_request_forms, parameter_request_all[0].parameter_group_id)
  83.     n_parameter_response(parameter_response_forms,parameter_response_all[0].parameter_group_id)
  84.     return render_template("front_interface.html",
  85.                            model_id=model_id,
  86.                            model_one=model_one,
  87.                            interface_model_forms=interface_model_forms,
  88.                            interface_model_one=interface_model_one,
  89.                            g_parameter_request=g_parameter_request,
  90.                            g_parameter_response=g_parameter_response)
  91. # 请求参数排序
  92. def n_parameter_request(request, parameter_group_id):
  93.     for form in request:
  94.         if form["parameter_group_id"] == parameter_group_id:
  95.             new_parameter_group_id = form["parameter_id"]
  96.             g_parameter_request.append(form)
  97.             n_parameter_request(request, new_parameter_group_id)
  98.     return g_parameter_request
  99. # 返回参数排序
  100. def n_parameter_response(response, parameter_group_id):
  101.     for form in response:
  102.         if form["parameter_group_id"] == parameter_group_id:
  103.             new_parameter_group_id = form["parameter_id"]
  104.             g_parameter_response.append(form)
  105.             n_parameter_response(response, new_parameter_group_id)
  106.     return g_parameter_response
  107. # 后台首页
  108. @app.route("/home", methods=["GET", "POST"])
  109. def home():
  110.     if not session.get("logged_in"):
  111.         return redirect(url_for("login"))
  112.     return render_template("home.html")
  113. # 后台登录
  114. @app.route("/login", methods=["GET", "POST"])
  115. def login():
  116.     form = LoginForm()
  117.     if form.validate_on_submit():
  118.         try:
  119.             user_one = User.query.filter_by(user_name=form.username.data).first()
  120.             me=user_one.check_password(form.password.data)
  121.             if me==True  and user_one.status == 1:
  122.                 session["logged_in"] = True
  123.                 return redirect(url_for("home"))
  124.             else:
  125.                 flash('登录密码错误！请检测你的密码')
  126.                 return render_template("login.html", form=form)
  127.         except AttributeError:
  128.             flash('登录fail！')
  129.             return render_template("login.html", form=form)
  130.     return render_template("login.html",
  131.                            form=form)
  132. # 后台登出
  133. @app.route("/logout", methods=["GET", "POST"])
  134. def logout():
  135.     session.pop("logged_in", None)
  136.     return redirect(url_for("index"))
  137. # 模块管理
  138. @app.route("/model", methods=["GET", "POST"])
  139. def model():
  140.     if not session.get("logged_in"):
  141.         return redirect(url_for("login"))
  142.     model_all = Model.query.all()
  143.     model_forms = []
  144.     for i in range(len(model_all)):
  145.         model_form = {"model_id": model_all[i].model_id,
  146.                       "model_name": model_all[i].model_name}
  147.         model_forms.append(model_form)
  148.     return render_template("model.html",
  149.                            model_forms=model_forms)
  150. # 新增模块
  151. @app.route("/addmodel", methods=["GET", "POST"])
  152. def addmodel():
  153.     if not session.get("logged_in"):
  154.         return redirect(url_for("login"))
  155.     add_model = ModelForm()
  156.     submit = SubmitForm()
  157.     if submit.validate_on_submit():
  158.         add = Model(model_name=add_model.model_name.data)
  159.         db.session.add(add)
  160.         db.session.commit()
  161.         return redirect(url_for("model"))
  162.     return render_template("addmodel.html",
  163.                            add_model=add_model,
  164.                            submit=submit)
  165. # 编辑模块
  166. @app.route("/editmodel/<model_id>", methods=["GET", "POST"])
  167. def editmodel(model_id):
  168.     if not session.get("logged_in"):
  169.         return redirect(url_for("login"))
  170.     model_one = Model.query.filter_by(model_id=model_id).first()
  171.     edit_model = ModelForm()
  172.     submit = SubmitForm()
  173.     if submit.validate_on_submit():
  174.         model_one.model_name = edit_model.model_name.data
  175.         db.session.commit()
  176.         return redirect(url_for("model"))
  177.     edit_model.model_name.data = model_one.model_name
  178.     return render_template("editmodel.html",
  179.                            edit_model=edit_model,
  180.                            submit=submit)
  181. # 接口列表
  182. @app.route("/interface/<model_id>")
  183. def interface(model_id):
  184.     if not session.get("logged_in"):
  185.         return redirect(url_for("login"))
  186.     interface_model_all = Interface.query.filter_by(model_id=model_id).all()
  187.     interface_model_forms = []
  188.     for i in range(len(interface_model_all)):
  189.         interface_model_form = {"interface_id": interface_model_all[i].interface_id,
  190.                                 "interface_name": interface_model_all[i].interface_name,
  191.                                 "interface_url": interface_model_all[i].interface_url}
  192.         interface_model_forms.append(interface_model_form)
  193.     return render_template("interface.html",
  194.                            model_id=model_id,
  195.                            interface_model_forms=interface_model_forms)
  196. # 新增接口
  197. @app.route("/addinterface/<model_id>", methods=["GET", "POST"])
  198. def addinterface(model_id):
  199.     if not session.get("logged_in"):
  200.         return redirect(url_for("login"))
  201.     add_interface = InterfaceForm()
  202.     submit = SubmitForm()
  203.     if submit.validate_on_submit():
  204.         add = Interface(interface_name=add_interface.interface_name.data,
  205.                         model_id=model_id,
  206.                         interface_url=add_interface.interface_url.data,
  207.                         interface_methd=add_interface.interface_method.data,
  208.                         request_exam=add_interface.request_exam.data,
  209.                         reposnese_exam=add_interface.response_exam.data)
  210.         db.session.add(add)
  211.         db.session.commit()
  212.         return redirect(url_for("interface",
  213.                                 model_id=model_id))
  214.     return render_template("addinterface.html",
  215.                            add_interface=add_interface,
  216.                            model_id=model_id,
  217.                            submit=submit)
  218. # 编辑接口
  219. @app.route("/editinterface/<model_id>&<interface_id>", methods=["GET", "POST"])
  220. def editinterface(model_id, interface_id):
  221.     if not session.get("logged_in"):
  222.         return redirect(url_for("login"))
  223.     interface_model_one = Interface.query.filter_by(interface_id=interface_id).first()
  224.     edit_interface_model = InterfaceForm()
  225.     submit = SubmitForm()
  226.     if submit.validate_on_submit():
  227.         interface_model_one.interface_name = edit_interface_model.interface_name.data
  228.         interface_model_one.interface_url = edit_interface_model.interface_url.data
  229.         interface_model_one.interface_methd = edit_interface_model.interface_method.data
  230.         interface_model_one.request_exam = edit_interface_model.request_exam.data
  231.         interface_model_one.response_exam = edit_interface_model.response_exam.data
  232.         db.session.commit()
  233.         return redirect(url_for("interface",
  234.                                 model_id=model_id))
  235.     edit_interface_model.interface_name.data = interface_model_one.interface_name
  236.     edit_interface_model.interface_url.data = interface_model_one.interface_url
  237.     edit_interface_model.interface_method.data = interface_model_one.interface_methd
  238.     edit_interface_model.request_exam.data = interface_model_one.request_exam
  239.     edit_interface_model.response_exam.data = interface_model_one.reposnese_exam
  240.     return render_template("editinterface.html",
  241.                            model_id=model_id,
  242.                            interface_id=interface_id,
  243.                            edit_interface_model=edit_interface_model,
  244.                            submit=submit)
  245. # 请求参数列表
  246. @app.route("/parameter_request/<model_id>&<interface_id>", methods=["GET", "POST"])
  247. def parameter_request(model_id, interface_id):
  248.     if not session.get("logged_in"):
  249.         return redirect(url_for("login"))
  250.     parameter_request_all = Parameter.query.filter_by(interface_id=interface_id, parameter_type=10).all()
  251.     parameter_request_forms = []
  252.     for i in range(len(parameter_request_all)):
  253.         parameter_request_form = {"parameter_id": parameter_request_all[i].parameter_id,
  254.                                   "parameter_name": parameter_request_all[i].parameter_name,
  255.                                   "necessary": parameter_request_all[i].necessary,
  256.                                   "type": parameter_request_all[i].type,
  257.                                   "default": parameter_request_all[i].default,
  258.                                   "remark": parameter_request_all[i].remark,
  259.                                   "parameter_group_id": parameter_request_all[i].parameter_group_id,
  260.                                   "level": parameter_request_all[i].level}
  261.         parameter_request_forms.append(parameter_request_form)
  262.     return render_template("parameter_request.html",
  263.                            model_id=model_id,
  264.                            interface_id=interface_id,
  265.                            parameter_request_forms=parameter_request_forms)
  266. # 新增请求参数
  267. @app.route("/addparameter_request/<model_id>&<interface_id>", methods=["GET", "POST"])
  268. def addparameter_request(model_id, interface_id):
  269.     if not session.get("logged_in"):
  270.         return redirect(url_for("login"))
  271.     add_parameter_request = ParameterRequestForm()
  272.     submit = SubmitForm()
  273.     if submit.validate_on_submit():
  274.         add = Parameter(interface_id=interface_id,
  275.                         parameter_type=10,
  276.                         parameter_group_id=add_parameter_request.parameter_group_id.data,
  277.                         parameter_name=add_parameter_request.parameter_name.data,
  278.                         necessary=add_parameter_request.necessary.data,
  279.                         type=add_parameter_request.type.data,
  280.                         default=add_parameter_request.default.data,
  281.                         remark=add_parameter_request.remark.data,
  282.                         level=add_parameter_request.level.data)
  283.         db.session.add(add)
  284.         db.session.commit()
  285.         return redirect(url_for("parameter_request",
  286.                                 model_id=model_id,
  287.                                 interface_id=interface_id))
  288.     return render_template("addparameter_request.html",
  289.                            add_parameter_request=add_parameter_request,
  290.                            model_id=model_id,
  291.                            interface_id=interface_id,
  292.                            submit=submit)
  293. # 编辑请求参数
  294. @app.route("/editparameter_request/<model_id>&<interface_id>&<parameter_id>", methods=["GET", "POST"])
  295. def editparameter_request(model_id, interface_id, parameter_id):
  296.     if not session.get("logged_in"):
  297.         return redirect(url_for("login"))
  298.     parameter_request_one = Parameter.query.filter_by(parameter_id=parameter_id).first()
  299.     edit_parameter_request = ParameterRequestForm()
  300.     submit = SubmitForm()
  301.     if submit.validate_on_submit():
  302.         parameter_request_one.parameter_name = edit_parameter_request.parameter_name.data
  303.         parameter_request_one.necessary = edit_parameter_request.necessary.data
  304.         parameter_request_one.type = edit_parameter_request.type.data
  305.         parameter_request_one.default = edit_parameter_request.default.data
  306.         parameter_request_one.remark = edit_parameter_request.remark.data
  307.         parameter_request_one.parameter_group_id = edit_parameter_request.parameter_group_id.data
  308.         parameter_request_one.level = edit_parameter_request.level.data
  309.         db.session.commit()
  310.         return redirect(url_for("parameter_request",
  311.                                 model_id=model_id,
  312.                                 interface_id=interface_id))
  313.     edit_parameter_request.parameter_name.data = parameter_request_one.parameter_name
  314.     edit_parameter_request.necessary.data = parameter_request_one.necessary
  315.     edit_parameter_request.type.data = parameter_request_one.type
  316.     edit_parameter_request.default.data = parameter_request_one.default
  317.     edit_parameter_request.remark.data = parameter_request_one.remark
  318.     edit_parameter_request.parameter_group_id.data = parameter_request_one.parameter_group_id
  319.     edit_parameter_request.level.data = parameter_request_one.level
  320.     return render_template("editparameter_request.html",
  321.                            model_id=model_id,
  322.                            interface_id=interface_id,
  323.                            parameter_id=parameter_id,
  324.                            edit_parameter_request=edit_parameter_request,
  325.                            submit=submit)
  326. # 删除请求参数
  327. @app.route("/deleteparameter_request/<model_id>&<interface_id>&<parameter_id>", methods=["GET", "POST"])
  328. def deleteparameter_request(model_id, interface_id, parameter_id):
  329.     if not session.get("logged_in"):
  330.         return redirect(url_for("login"))
  331.     deleteparameter_request_one = Parameter.query.filter_by(parameter_id=parameter_id).first()
  332.     db.session.delete(deleteparameter_request_one)
  333.     db.session.commit()
  334.     parameter_request_all = Parameter.query.filter_by(interface_id=interface_id, parameter_type=10).all()
  335.     parameter_request_forms = []
  336.     for i in range(len(parameter_request_all)):
  337.         parameter_request_form = {"parameter_id": parameter_request_all[i].parameter_id,
  338.                                   "parameter_name": parameter_request_all[i].parameter_name,
  339.                                   "necessary": parameter_request_all[i].necessary,
  340.                                   "type": parameter_request_all[i].type,
  341.                                   "default": parameter_request_all[i].default,
  342.                                   "remark": parameter_request_all[i].remark,
  343.                                   "parameter_group_id": parameter_request_all[i].parameter_group_id,
  344.                                   "level": parameter_request_all[i].level}
  345.         parameter_request_forms.append(parameter_request_form)
  346.     return render_template("parameter_request.html",
  347.                            model_id=model_id,
  348.                            interface_id=interface_id,
  349.                            parameter_request_forms=parameter_request_forms)
  350. # 返回参数列表
  351. @app.route("/parameter_response/<model_id>&<interface_id>", methods=["GET", "POST"])
  352. def parameter_response(model_id, interface_id):
  353.     if not session.get("logged_in"):
  354.         return redirect(url_for("login"))
  355.     parameter_response_all = Parameter.query.filter_by(interface_id=interface_id, parameter_type=20).all()
  356.     parameter_response_forms = []
  357.     for i in range(len(parameter_response_all)):
  358.         parameter_response_form = {"parameter_id": parameter_response_all[i].parameter_id,
  359.                                    "parameter_name": parameter_response_all[i].parameter_name,
  360.                                    "necessary": parameter_response_all[i].necessary,
  361.                                    "type": parameter_response_all[i].type,
  362.                                    "default": parameter_response_all[i].default,
  363.                                    "remark": parameter_response_all[i].remark,
  364.                                    "parameter_group_id": parameter_response_all[i].parameter_group_id,
  365.                                    "level": parameter_response_all[i].level}
  366.         parameter_response_forms.append(parameter_response_form)
  367.     return render_template("parameter_response.html",
  368.                            model_id=model_id,
  369.                            interface_id=interface_id,
  370.                            parameter_response_forms=parameter_response_forms)
  371. # 新增返回参数
  372. @app.route("/addparameter_response/<model_id>&<interface_id>", methods=["GET", "POST"])
  373. def addparameter_response(model_id, interface_id):
  374.     if not session.get("logged_in"):
  375.         return redirect(url_for("login"))
  376.     add_parameter_response = ParameterResponseForm()
  377.     submit = SubmitForm()
  378.     if submit.validate_on_submit():
  379.         add = Parameter(interface_id=interface_id,
  380.                         parameter_type=20,
  381.                         parameter_group_id=add_parameter_response.parameter_group_id.data,
  382.                         parameter_name=add_parameter_response.parameter_name.data,
  383.                         necessary=add_parameter_response.necessary.data,
  384.                         type=add_parameter_response.type.data,
  385.                         default=add_parameter_response.default.data,
  386.                         remark=add_parameter_response.remark.data,
  387.                         level=add_parameter_response.level.data)
  388.         db.session.add(add)
  389.         db.session.commit()
  390.         return redirect(url_for("parameter_response",
  391.                                 model_id=model_id,
  392.                                 interface_id=interface_id))
  393.     return render_template("addparameter_response.html",
  394.                            add_parameter_response=add_parameter_response,
  395.                            model_id=model_id,
  396.                            interface_id=interface_id,
  397.                            submit=submit)
  398. # 编辑返回参数
  399. @app.route("/editparameter_response/<model_id>&<interface_id>&<parameter_id>", methods=["GET", "POST"])
  400. def editparameter_response(model_id, interface_id, parameter_id):
  401.     if not session.get("logged_in"):
  402.         return redirect(url_for("login"))
  403.     parameter_response_one = Parameter.query.filter_by(parameter_id=parameter_id).first()
  404.     edit_parameter_response = ParameterResponseForm()
  405.     submit = SubmitForm()
  406.     if submit.validate_on_submit():
  407.         parameter_response_one.parameter_name = edit_parameter_response.parameter_name.data
  408.         parameter_response_one.necessary = edit_parameter_response.necessary.data
  409.         parameter_response_one.type = edit_parameter_response.type.data
  410.         parameter_response_one.default = edit_parameter_response.default.data
  411.         parameter_response_one.remark = edit_parameter_response.remark.data
  412.         parameter_response_one.parameter_group_id = edit_parameter_response.parameter_group_id.data
  413.         parameter_response_one.level = edit_parameter_response.level.data
  414.         db.session.commit()
  415.         return redirect(url_for("parameter_response",
  416.                                 model_id=model_id,
  417.                                 interface_id=interface_id))
  418.     edit_parameter_response.parameter_name.data = parameter_response_one.parameter_name
  419.     edit_parameter_response.necessary.data = parameter_response_one.necessary
  420.     edit_parameter_response.type.data = parameter_response_one.type
  421.     edit_parameter_response.default.data = parameter_response_one.default
  422.     edit_parameter_response.remark.data = parameter_response_one.remark
  423.     edit_parameter_response.parameter_group_id.data = parameter_response_one.parameter_group_id
  424.     edit_parameter_response.level.data = parameter_response_one.level
  425.     return render_template("editparameter_response.html",
  426.                            model_id=model_id,
  427.                            interface_id=interface_id,
  428.                            parameter_id=parameter_id,
  429.                            edit_parameter_response=edit_parameter_response,
  430.                            submit=submit)
  431. # 删除返回参数
  432. @app.route("/deleteparameter_response/<model_id>&<interface_id>&<parameter_id>", methods=["GET", "POST"])
  433. def deleteparameter_response(model_id, interface_id, parameter_id):
  434.     if not session.get("logged_in"):
  435.         return redirect(url_for("login"))
  436.     deleteparameter_response_one = Parameter.query.filter_by(parameter_id=parameter_id).first()
  437.     db.session.delete(deleteparameter_response_one)
  438.     db.session.commit()
  439.     parameter_response_all = Parameter.query.filter_by(interface_id=interface_id, parameter_type=20).all()
  440.     parameter_response_forms = []
  441.     for i in range(len(parameter_response_all)):
  442.         parameter_response_form = {"parameter_id": parameter_response_all[i].parameter_id,
  443.                                    "parameter_name": parameter_response_all[i].parameter_name,
  444.                                    "necessary": parameter_response_all[i].necessary,
  445.                                    "type": parameter_response_all[i].type,
  446.                                    "default": parameter_response_all[i].default,
  447.                                    "remark": parameter_response_all[i].remark,
  448.                                    "parameter_group_id": parameter_response_all[i].parameter_group_id,
  449.                                    "level": parameter_response_all[i].level}
  450.         parameter_response_forms.append(parameter_response_form)
  451.     return render_template("parameter_response.html",
  452.                            model_id=model_id,
  453.                            interface_id=interface_id,
  454.             parameter_response_forms=parameter_response_forms)
  455. # 用户管理
  456. @app.route("/users", methods=["GET", "POST"])
  457. def user():
  458.     if not session.get("logged_in"):
  459.         return redirect(url_for("login"))
  460.     user_all = User.query.filter_by(status=1).all()
  461.     user_forms = []
  462.     for i in range(len(user_all)):
  463.         user_form = {"user_id": user_all[i].uer_id,
  464.                      "user_name": user_all[i].user_name,
  465.                      "password": user_all[i].password[:30],
  466.                      "status": user_all[i].status,
  467.                      "level": user_all[i].level,
  468.                      "user_zhuce_date": user_all[i].user_zhuce_date,
  469.                      "user_zhuce_email": user_all[i].user_zhuce_email,
  470.                      "user_iphone": user_all[i].user_iphone,
  471.                      "user_qq": user_all[i].user_qq
  472.                      }
  473.         user_forms.append(user_form)
  474.     return render_template("user_admin.html",
  475.                            user_forms=user_forms)
  476. #注册
  477. @app.route('/register',methods=['GET','POST'])
  478. def registser():
  479.     form = ReguistForm()
  480.     if form.validate_on_submit():
  481.         user=form.user_name.data
  482.         me=User.query.filter_by(user_name=user).first()
  483.         if me:
  484.             flash('用户名已经存在！')
  485.             return  render_template('regist.html',form=form)
  486.         if form.que_password.data != form.password.data:
  487.             flash(' 确认密码是否一致！')
  488.             return  render_template('regist.html',form=form)
  489.         passw=form.password.data
  490.         print(passw)
  491.         add=User(
  492.             user_name=form.user_name.data,
  493.             status=1,
  494.             user_zhuce_email=form.email.data,
  495.             user_iphone=form.iphone.data,
  496.             user_qq=form.qq.data,
  497.             user_zhuce_date=datetime.datetime.now()
  498.                 )
  499.         add.set_password(password=passw)
  500.         db.session.add(add)
  501.         db.session.commit()
  502.         return  redirect(url_for('login'))
  503.     return render_template("regist.html",
  504.                            form=form)
  505. #删除用户
  506. @app.route('/delete/<user_name>',methods=['GET','POST'])
  507. def delete(user_name):
  508.     if not session.get("logged_in"):
  509.         return redirect(url_for("login"))
  510.     delete_user=User.query.filter_by(user_name=user_name).first()
  511.     db.session.delete(delete_user)
  512.     db.session.commit()
  513.     user_all = User.query.filter_by(status=1).all()
  514.     user_forms = []
  515.     for i in range(len(user_all)):
  516.         user_form = {"user_id": user_all[i].uer_id,
  517.                      "user_name": user_all[i].user_name,
  518.                      "password": user_all[i].password[:30],
  519.                      "status": user_all[i].status,
  520.                      "level": user_all[i].level,
  521.                      "user_zhuce_date": user_all[i].user_zhuce_date,
  522.                      "user_zhuce_email": user_all[i].user_zhuce_email,
  523.                      "user_iphone": user_all[i].user_iphone,
  524.                      "user_qq": user_all[i].user_qq
  525.                      }
  526.         user_forms.append(user_form)
  527.     return render_template("user_admin.html",
  528.                            user_forms=user_forms)

forms 表单代码如下：

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3.  
  4. from flask_wtf import Form
  5. from wtforms import StringField, TextField, PasswordField, FormField, SubmitField, FieldList, IntegerField
  6. from wtforms.validators import Required, DataRequired
  7.  
  8. class LoginForm(Form):
  9.     username = StringField("登陆名", validators=[Required()])
  10.     password = PasswordField("密码", validators=[Required()])
  11.  
  12. class ModelForm(Form):
  13.     model_name = StringField("中文名称", validators=[Required()])
  14.  
  15. class InterfaceForm(Form):
  16.     interface_name = StringField("接口名称", validators=[Required()])
  17.     interface_url = StringField("接口地址", validators=[Required()])
  18.     interface_method = StringField("接口方法", validators=[Required()])
  19.     request_exam = TextField("请求示例", validators=[Required()])
  20.     response_exam = TextField("返回示例", validators=[Required()])
  21.  
  22. class ParameterRequestForm(Form):
  23.     parameter_group_id = StringField("从属", validators=[Required()])
  24.     parameter_name = StringField("参数名称", validators=[Required()])
  25.     necessary = StringField("是否必须", validators=[Required()])
  26.     type = StringField("类型", validators=[Required()])
  27.     default = StringField("默认值", validators=[Required()])
  28.     remark = StringField("备注", validators=[Required()])
  29.     level = StringField("层级", validators=[Required()])
  30.  
  31. class ParameterResponseForm(Form):
  32.     parameter_group_id = StringField("从属", validators=[Required()])
  33.     parameter_name = StringField("参数名称", validators=[Required()])
  34.     necessary = StringField("是否必须", validators=[Required()])
  35.     type = StringField("类型", validators=[Required()])
  36.     default = StringField("示例", validators=[Required()])
  37.     remark = StringField("描述", validators=[Required()])
  38.     level = StringField("层级", validators=[Required()])
  39.  
  40. class SubmitForm(Form):
  41.     submit = SubmitField("保存")
  42.  
  43. class ReguistForm(Form):#注册
  44.     user_name=StringField('用户名',validators=[Required()])
  45.     password=PasswordField('密码',validators=[Required()])
  46.     que_password=PasswordField('密码',validators=[Required()])
  47.     iphone=IntegerField('手机号',validators=[Required()])
  48.     qq=IntegerField('qq号',validators=[Required()])
  49.     email=StringField('邮箱',validators=[Required()])

效果如下图：

原文地址：https://www.cnblogs.com/leiziv5/p/6830256.html

git地址https://github.com/liwanlei/plmock

百度网盘地址https://pan.baidu.com/disk/home#/all?vmode=list&path=%2Fpython%2Bflask%E5%BC%80%E5%8F%91%E6%8E%A5%E5%8F%A3%E6%B5%8B%E8%AF%95%E5%B9%B3%E5%8F%B0

flask 开发接口测试平台的更多相关文章

  1. flask + Python3 实现的的API自动化测试平台---- IAPTest接口测试平台，更名：FXTest 接受定制开发（java版开发完毕）

    **背景: 1.平时测试接口,总是现写代码,对测试用例的管理,以及测试报告的管理持久化做的不够,              2.工作中移动端开发和后端开发总是不能并行进行,需要一个mock的依赖来让他 ...

  2. flask + Python3 实现的的API自动化测试平台---- IAPTest接口测试平台（总结感悟篇）

    前言: 在前进中去发现自己的不足,在学习中去丰富自己的能力,在放弃时想想自己最初的目的,在困难面前想想怎么踏过去.在不断成长中去磨炼自己. 正文: 时间轴 flask + Python3 实现的的AP ...

  3. flask + Python3 实现的的API自动化测试平台---- IAPTest接口测试平台

    **背景: 1.平时测试接口,总是现写代码,对测试用例的管理,以及测试报告的管理持久化做的不够,              2.工作中移动端开发和后端开发总是不能并行进行,需要一个mock的依赖来让他 ...

  4. django开发自动化测试平台简介

    Django的优点 1:功能完善.要素齐全:自带大量常用工具和框架(比如分页,auth,权限管理), 适合快速开发企业级网站. 2:完善的文档:经过十多年的发展和完善,Django有广泛的实践案例和完 ...

  5. flask开发restful api

    flask开发restful api 如果有几个原因可以让你爱上flask这个极其灵活的库,我想蓝图绝对应该算上一个,部署蓝图以后,你会发现整个程序结构非常清晰,模块之间相互不影响.蓝图对restfu ...

  6. Jenkins+Ant+Jmeter搭建持续集成的接口测试平台（转）

    一.什么是接口测试? 接口测试是测试系统组件间接口的一种测试.接口测试主要用于检测外部系统与系统之间以及内部各个子系统之间的交互点.测试的重点是要检查数据的交换,传递和控制管理过程,以及系统间的相互逻 ...

  7. 【转】Jenkins+Ant+Jmeter搭建持续集成的接口测试平台

    一.什么是接口测试? 接口测试是测试系统组件间接口的一种测试.接口测试主要用于检测外部系统与系统之间以及内部各个子系统之间的交互点.测试的重点是要检查数据的交换,传递和控制管理过程,以及系统间的相互逻 ...

  8. Linux下搭建HttpRunnerManager接口测试平台

    前言 之前在学习HttpRunner时,我们都是把用例写在 YAML/JSON 中进行维护,使用起来也很方便.其实,现在有不少大佬都喜欢开发自动化测试平台,比如我们今天要搭建的HttpRunnerMa ...

  9. Flask开发系列之Flask+redis实现IP代理池

    Flask开发系列之Flask+redis实现IP代理池 代理池的要求 多站抓取,异步检测:多站抓取:指的是我们需要从各大免费的ip代理网站,把他们公开的一些免费代理抓取下来:一步检测指的是:把这些代 ...

随机推荐

  1. restfulframework引用多对多外键

    记录一下工作中遇到的问题 最近在写restfulframework,感觉还是很便利的 首先贴一下文档地址 https://www.django-rest-framework.org/api-guide ...

  2. c# 将两个表的有效数据合到一个表中

    <asp:DropDownList ID="ddlSpecialty" runat="server" > </asp:DropDownList ...

  3. MySQL Install--MySQL安装相关知识和问题

    1.mysqld和mysqld_safe之间关系 mysqld_safe是一个启动脚本,用来启动MySQL服务器并监控MySQL服务的运行情况,并在其服务出现故障宕机后重启其服务. mysql.ser ...

  4. 关于 Spring AOP (AspectJ) 你该知晓的一切

    版权声明:本文为CSDN博主「zejian_」的原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接及本声明.原文链接:https://blog.csdn.net/javazej ...

  5. matplotlib绘图难题解决

    # coding=utf-8 import pandas as pd import yagmail import requests import arrow import numpy as np im ...

  6. vsftpd配置文件

    一.默认配置 1. 允许匿名用户和本地用户登录 anonymous_enable=YES local_enable=YES 2. 匿名用户使用的登录名为ftp或anonymous,密码为空:匿名用户不 ...

  7. kubernetes 清理孤儿POD--转发

    孤儿pod的产生 节点OOM以后或者节点异常崩溃的情况下,pod未能被正常的清理而导致的孤儿进程. 提示如下 Orphaned pod found - but volume paths are sti ...

  8. httpd的压力测试工具-ab工具使用案例

    httpd的压力测试工具-ab工具使用案例 作者:尹正杰 版权声明:原创作品,谢绝转载!否则将追究法律责任.   一.httpd自带的工具程序 事实上,在我们安装完Apache之后,它默认就会给我们安 ...

  9. Python爬取mn52网站美女图片以及图片防盗链的解决方法

    防盗链原理 http标准协议中有专门的字段记录referer 一来可以追溯上一个入站地址是什么 二来对于资源文件,可以跟踪到包含显示他的网页地址是什么 因此所有防盗链方法都是基于这个Referer字段 ...

  10. Supermarket（贪心/并查集）

    题目链接 原创的博客 题意: 超市里有N个商品. 第i个商品必须在保质期(第di天)之前卖掉, 若卖掉可让超市获得pi的利润. 每天只能卖一个商品. 现在你要让超市获得最大的利润. n , p[i], ...