p2p开户银行审核模块功能实现

审核模块简介

用户提交开户申请后要等待审核通过才能审核成功
审核需要银行系统进行开户 使用flask框架搭建一个银行系统
用户提交审核 银行进行开户，在返回p2p后台通过审核

flask搭建测试银行系统

利用工厂模式搭建一个flask框架

app.py

from flask import Flask

def current_app():
    app = Flask(__name__)
    return app
app = current_app()

main.py

from app import app
from flask_cors import CORS
from comm.config import Config
from views.user import user_blue

#日志模块
import logging
from logging import FileHandler

app.config.from_object(Config)
CORS(app)

app.register_blueprint(user_blue)

if __name__=="__main__":
    handler = logging.FileHandler("logs/"+'log.txt')
    app.logger.addHandler(handler)
    app.run()

要创建一个新的mysql和表

# 用户表
create table user(
    id int primary key auto_increment,
    username varchar(50),
    password varchar(50),
    name varchar(50)
);
# 银行表 
create table bank(
    id int primary key auto_increment,
    card_number varchar(18),   # 身份证
    bank_code varchar(50),  # 银行卡
    name varchar(50),   # 用户名称
    user_id int 
  );
 
# 充值表
create table recharge(
    id int primary key auto_increment,
    user_id int,
    money decimal(10,2) default(0)    
);  

在views文件夹里创建py文件进行编写
将传递过来的名字 id等信息生成token返回
加一个装饰器 每次请求前验证token 如果不符合则报401
注意：两个装饰器的情况下会报错 需要导入 functools 命名装饰器解决
将传递的用户信息存入银行客户表中

from flask import Blueprint, jsonify
from flask_restful import reqparse
from db import db
import datetime, jwt
import time
import uuid
from flask import current_app as app, request
from utils.JwtTools import jwttool

user_blue = Blueprint('user', __name__)


import functools
# 加入授权
def istoken(func):
    functools.wraps(func)
    def weiend(*args, **kwargs):
        req = reqparse.RequestParser()
        req.add_argument("token")
        arse = req.parse_args()
        # 验证码token
        payload = jwttool.valid(arse["token"])
        if not payload:
            return jsonify({"code": 401})
        return func(*args, **kwargs)
    return weiend

# 生成token
@user_blue.route("/token")
def token_user():
    req = reqparse.RequestParser()
    req.add_argument("name")
    req.add_argument("userid")
    req.add_argument("appname")
    arse = req.parse_args()

    # 加入用户
    username = uuid.uuid4().hex
    password = uuid.uuid4().hex
    sql = "insert into user(username, password, name) values ('%s','%s','%s')" %(username, password, arse["appname"])
    db.update(sql)
    db.commit()

    # 生成token
    names=str(arse["name"])
    userid=str(arse["userid"])
    payload = {'name': names, 'userid': userid, 'exp': time.time() + 1296000}
    token = jwt.encode(payload, '1', algorithm='HS256')
    return jsonify({'code': 200, 'token': token})

# 给用户进行开户
@user_blue.route("/apply")
@istoken
def open_user():
    req = reqparse.RequestParser()
    req.add_argument("card_number")
    req.add_argument("bank_code")
    req.add_argument("name")
    arse = req.parse_args()

    # 加入银行管理平台数据库
    sql = "insert into bank(card_number, bank_code, name) values('%s','%s','%s')" %(arse['card_number'],arse['bank_code'],arse['name'])
    db.update(sql)
    db.commit()
    return jsonify({'code': 200})

# 进行去钱
@user_blue.route('/recharge')
def recharge():
    req = reqparse.RequestParser()
    req.add_argument("user_id")
    req.add_argument("money")
    arse = req.parse_args()

    print(arse)
    sql = f"insert into recharge(user_id, money) values ({arse['user_id']},{arse['money']})"
    db.update(sql)
    db.commit()

    return jsonify({'code': 200})

审核接口

在创建好的utils文件夹中创建test.go文件进行配置
由于银行系统是自己做出来进行测试的 审核自动进行
用户提交开户申请 系统每隔一段时间自动进行审核
发布开户信息到银行存管平台
调用flask银行后台接口，先获取生成的token
然后进行开户申请，审核通过

package utils
import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"myproject/model"
	"net/http"
	"net/url"
	"time"
)
// 发布开户信息到银行存管平台
func TestOpen() {
	//一直在执行的任务
	//从redis中读取任务
	//查询信息
	//调用银行存管平台接口
	r := RedisPool
	for {
		//获取长度，判断队列中是否有信息
		len := r.ListLen("openuser")
		if len > 0 {
			//从队列中取一个信息l.ListRange(key,start,end)
			openId := r.ListPop("openuser")
			// 获取数据库中的数据
			open_info := &model.OpenBank{}
			model.GetDb().Find(open_info, "id=?", openId)
			// 定义切片
			data := make(map[string]interface{})
			data["name"] = open_info.Name
			data["userid"] = open_info.Userid

			// 获取token
			token := openToekn(data)

			// 申请开户
			code := openUser(token, open_info.CardNumber, open_info.BankCode, open_info.Name)
			db := model.GetDb()
			sql := "update open_banks set status=? where id=?"
			if code == 200 {
				// 更新状态
				db.Exec(sql, 1, openId)
				fmt.Println("===已通过审核===")
			} else {
				// 更新状态
				db.Exec(sql, 0, openId)
				fmt.Println("---未通过审核---")
			}
		}
		fmt.Println(time.Now())
		time.Sleep(time.Second * 10)
	}
}
// 获取token
func openToekn(datas map[string]interface{}) string {
	var host = "http://127.0.0.1:5000/token"
	var param = map[string]string{
		"name":    fmt.Sprint(datas["name"]),
		"appname": "p2p",
		"userid":  fmt.Sprint(datas["userid"]),
	}

	uri, err := url.Parse(host)
	if err != nil {
		fmt.Println(err)
	}
	query := uri.Query()
	for k, v := range param {
		query.Set(k, v)
	}
	uri.RawQuery = query.Encode()

	response, err := http.Get(uri.String())
	if err != nil {
		fmt.Println(err)
	}
	result, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
	}
	//fmt.Println(">>", string(result))

	var v interface{}
	_ = json.Unmarshal([]byte(string(result)), &v)
	data := v.(map[string]interface{})

	return data["token"].(string)
}
// 开户申请
func openUser(token, card_number, bank_code, name string) float64 {
	var host = "http://127.0.0.1:5000/apply"
	var param = map[string]string{
		"token":       fmt.Sprint(token),
		"card_number": card_number,
		"bank_code":   bank_code,
		"name":        name,
	}

	uri, err := url.Parse(host)
	if err != nil {
		fmt.Println(err)
	}
	query := uri.Query()
	for k, v := range param {
		query.Set(k, v)
	}
	uri.RawQuery = query.Encode()

	response, err := http.Get(uri.String())
	if err != nil {
		fmt.Println(err)
	}
	result, err := ioutil.ReadAll(response.Body)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println(">>", string(result))
	fmt.Printf("type: %T\n", result)

	var v interface{}
	_ = json.Unmarshal([]byte(string(result)), &v)
	data := v.(map[string]interface{})
	fmt.Println(data["code"])
	
	return data["code"].(float64)
}

在main里导入 自动执行

func main() {
	model.InitDB()       //导入model
	utils.ConnectRedis() //导入redis
	go utils.TestOpen()  // 导入开户
	// 1.创建路由
	r := gin.Default()

	r.Use(Cors())      //配置跨域
	route.PathRoute(r) //导入路由
	r.Run(":8000")
}