微信推送和支付宝付款接口的使用

  我们在开发的过程中经常会碰到调用微信或者支付宝接口进行付款,付款完成之后,如果用户绑定了我的账号,我只要有活动了,就要给这个关注我的用户推动消息,让用户知道,比如说,我们经常会关注一些公众号,然后这些公众号只要有了消息就会自动给我推送,我们以后也会遇到这种推送的需求,那么具体如何使用我们的代码来实现这种需求呢?还有就是用户在付款的时候,我如何给他调用支付宝的接口呢?下面我们就来具体的学习

一、支付宝付款

  目前我们的付款方式有支付宝支付,微信支付,银联支付,然后使用支付宝支付需要有一个商户号,这个需要自己公司去申请(需要企业营业执照),申请完之后会有一个商户号,我们这边主要是使用一种沙箱测试环境,沙箱环境地址如下

https://openhome.alipay.com/platform/appDaily.htm?tab=info

 进入以后,我们就可以申请个人的商户号了,如下图所示

第一步、进入沙箱测试环境

第二步、生成商户公钥和支付宝公钥

第三步、下载沙箱测试应用

我们在使用的时候,调用支付宝接口和支付宝返回给我们数据的时候,传输过程中数据都是加密的,那么简单的复习一下加密方式

对称加密:所谓的对称加密就是指加密密钥和解密密钥使用的是同一个,这样只要我们保证了这个私钥不泄露,数据就是安全的

非对称加密:加密和解密的密钥是不同的,使用公钥加密,然后使用私钥进行解密,公钥可以随意分发给任何人,但是私钥一定不能泄露,比如支付宝的公钥就是公开的,用户使用支付宝的公钥进行数据的加密,传输给支付宝,然后支付宝通过自己的私钥进行解密,这样就可以达到数据的传输,而且在传输的过程中,就算被别人截取了,他由于不知道支付宝的私钥,所以对于我们来说这个数据也是安全的。

  我们在使用加密的时候,需要使用第三方的模块,安装如下

pip3 install pycryptodome

二、支付宝支付流程

1、项目结构

 2、项目流程介绍

  1.拿到商户号,回调地址,支付宝公钥,商户私钥生成一个alipay对象

  2.对象点direct_pay,传支付金额,支付商品描述,支付订单号,然后返回一个加密的串,这个加密串包含了第一步的信息

  3.将拿到的串拼接到支付宝网关(测试/正式)的后面pay_url="https://openapi.alipaydev.com/gateway.do?{}".format(query_params)

  4.向生成的地址发送get请求,会跳转到支付宝的支付页面

  5.用户付款完成(此时钱已经进入了商户号),支付宝收到付款,向我们配置的两个回调地址发送请求(get,post)

  6.一般get请求用户展示,post请求用于修改订单状态,我们在拿到请求的时候一定要验签(防止仿造支付宝向我们发送请求)

    -get请求一般用于页面展示

    -post请求用于修改订单状态

项目中需要配置的东西如下:

  1.公钥私钥生成方式:https://docs.open.alipay.com/291/105971

    支付宝公钥:商户号中输入的应用公钥,会自动生成一个支付宝公钥,直接黏贴过来就好

    应用私钥(用户私钥)

  2.支付宝回调返回数据中会有

    singn:必须验证签名,验证通过以后才能进行后续的修改

    订单id:根据订单id修改订单状态

 可能遇到的问题处理:

  用户付款了,但正在这时,服务挂掉,收不到支付宝的回调数据,如何处理?

    如果服务挂掉了,支付宝会过一段时间自动在回调,在24h内,隔一段时间就会回调,这个时候我们只需要重启服务,就可以 接收到了!

3、代码展示

  首先是路由层,我们需要用到的是两个接口,一个用来向支付宝发起付款,一个用来接收支付宝收款成功之后返回给我们数据的接口,这里我们使用的是page1,page2

from django.contrib import admin

from django.conf.urls import url
from app01 import views

urlpatterns = [
    url('admin/', admin.site.urls),
    url(r'^page1/', views.page1),
    url(r'^page2/', views.page2),
]

视图函数展示

import json
import time


from django.shortcuts import render, redirect, HttpResponse


from myutils.pay import AliPay


def ali():
    # 沙箱环境地址:https://openhome.alipay.com/platform/appDaily.htm?tab=info
    app_id = "2016101000653326"
    # 支付宝收到用户的支付,会向商户发两个请求,一个get请求,一个post请求
    # POST请求,用于最后的检测
    notify_url = "http://127.0.0.1/page2/"
    # GET请求,用于页面的跳转展示
    return_url = "http://127.0.0.1/page2/"
    # 用户私钥
    merchant_private_key_path = "keys/app_private_2048.txt"
    # 支付宝公钥
    alipay_public_key_path = "keys/alipay_public_2048.txt"
    # 生成一个AliPay的对象,支付对象
    alipay = AliPay(
        appid=app_id,  # 商家的商户号
        app_notify_url=notify_url,  #
        return_url=return_url,
        # 商家私钥
        app_private_key_path=merchant_private_key_path,
        # 支付宝公钥  用于验证支付宝发送的消息的校验
        alipay_public_key_path=alipay_public_key_path,  # 支付宝的公钥,验证支付宝回传消息使用,不是你自己的公钥
        debug=True,  # 默认False,  是True的时候才会走沙箱环境,否则就是走的真正的支付接口
    )
    # 将阿里pay对象返回
    return alipay


def page1(request):
    if request.method == "GET":
        # get请求的话直接返回一个页面
        return render(request, 'page1.html')
    # 是post请求,那就要开始调用支付宝的接口
    else:
        money = float(request.POST.get('money'))
        # 这里是调用ali这个函数,开始执行内部的代码,然后将返回值接收
        alipay = ali()
        # 调用对象的direct_pay这个方法,将商品相关传进去,得到一个签名后的字符串
        query_params = alipay.direct_pay(
            subject="充气娃娃",  # 商品简单描述
            out_trade_no="x2" + str(time.time()),  # 商户订单号
            total_amount=money,  # 交易金额(单位: 元 保留俩位小数)
        )

        pay_url = "https://openapi.alipaydev.com/gateway.do?{}".format(query_params)
        print(pay_url)
        # 朝这个地址发get请求
        # from django.http import JsonResponse
        # return JsonResponse({'status':100,'url':pay_url})
        return redirect(pay_url)


def page2(request):
    # 支付宝如果收到用户的支付,支付宝会给我的地址发一个post请求,一个get请求
    alipay = ali()
    if request.method == "POST":
        # 检测是否支付成功
        # 去请求体中获取所有返回的数据:状态/订单号
        from urllib.parse import parse_qs
        body_str = request.body.decode('utf-8')
        print(body_str)

        post_data = parse_qs(body_str)
        print('支付宝给我的数据:::---------',post_data)
        post_dict = {}
        for k, v in post_data.items():
            post_dict[k] = v[0]
        print('转完之后的字典',post_dict)
        # 做二次验证
        sign = post_dict.pop('sign', None)
        # 通过调用alipay的verify方法去认证
        status = alipay.verify(post_dict, sign)

        print('POST验证', status)
        if status:
            # 修改自己订单状态
            pass
        return HttpResponse('POST返回')

    else:
        params = request.GET
        sign = params.pop('sign', None)
        status = alipay.verify(params, sign)
        print('GET验证', status)
        return HttpResponse('支付成功')
Views

在这里我们用到了alipay对象,现在展示alipay对象的代码,它里面做的具体操作如下

from datetime import datetime
from Crypto.PublicKey import RSA
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA256
from urllib.parse import quote_plus
from base64 import decodebytes, encodebytes
import json

# 这是alipay对象
class AliPay(object):
    """
    支付宝支付接口(PC端支付接口)
    """
    def __init__(self, appid, app_notify_url, app_private_key_path,
                 alipay_public_key_path, return_url, debug=False):
        self.appid = appid
        self.app_notify_url = app_notify_url
        self.app_private_key_path = app_private_key_path
        self.app_private_key = None  # 商家的私钥
        self.return_url = return_url  # 回来后的get请求地址
        with open(self.app_private_key_path) as fp:
            self.app_private_key = RSA.importKey(fp.read())
        self.alipay_public_key_path = alipay_public_key_path
        with open(self.alipay_public_key_path) as fp:
            self.alipay_public_key = RSA.importKey(fp.read())

        if debug is True:
            # 这里是调用它测试的接口
            self.__gateway = "https://openapi.alipaydev.com/gateway.do"
        else:
            # 这才是真正的支付接口
            self.__gateway = "https://openapi.alipay.com/gateway.do"

    def direct_pay(self, subject, out_trade_no, total_amount, return_url=None, **kwargs):
        biz_content = {
            "subject": subject,  # 商品
            "out_trade_no": out_trade_no,  # 订单号
            "total_amount": total_amount,  # 总金额
            "product_code": "FAST_INSTANT_TRADE_PAY",
            # "qr_pay_mode":4
        }

        biz_content.update(kwargs)
        # data
        data = self.build_body("alipay.trade.page.pay", biz_content, self.return_url)
        return self.sign_data(data)  # 签名后的字符串


    # 这个是用来创建请求的体,返回的data里面包含了请求方式,请求体,版本号
    def build_body(self, method, biz_content, return_url=None):
        data = {
            "app_id": self.appid,
            "method": method,
            "charset": "utf-8",
            "sign_type": "RSA2",  # 这是修改密钥的种类
            "timestamp": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            "version": "1.0",
            "biz_content": biz_content
        }

        if return_url is not None:
            data["notify_url"] = self.app_notify_url
            data["return_url"] = self.return_url

        return data

    def sign_data(self, data):
        data.pop("sign", None)
        # 排序后的字符串
        unsigned_items = self.ordered_data(data)  # 这里就是拿到排序后的列表套元组[(),(),()]
        # "{k}={v}&{}={}" name = egon & age = 18 拼接成urlencoded形式的编码
        unsigned_string = "&".join("{0}={1}".format(k, v) for k, v in unsigned_items)
        sign = self.sign(unsigned_string.encode("utf-8"))
        # ordered_items = self.ordered_data(data)
        quoted_string = "&".join("{0}={1}".format(k, quote_plus(v)) for k, v in unsigned_items)

        # 获得最终的订单信息字符串 签过名的字符串信息,利用商家的私钥签名
        signed_string = quoted_string + "&sign=" + quote_plus(sign)
        return signed_string

    def ordered_data(self, data):
        complex_keys = []
        # 对data进行取值
        for key, value in data.items():
            # 判断他的value类型是不是字典
            if isinstance(value, dict):
                # 是的话将这个key加到数组中biz_content
                complex_keys.append(key)

        # 将字典类型的数据dump出来
        for key in complex_keys:
            # 将字典取出后添加到整个大字典中,然后将后面的内容序列化  separators是用来获取不那么紧凑的json格式的数据
            data[key] = json.dumps(data[key], separators=(',', ':'))
        # 返回一个列表套元组的形式的数据,然后进行升序排序
        return sorted([(k, v) for k, v in data.items()])

    # 用来做签名相关
    def sign(self, unsigned_string):
        # 开始计算签名
        key = self.app_private_key   # 商家私钥
        signer = PKCS1_v1_5.new(key)  # 将商家私钥当作参数生成一个签名
        signature = signer.sign(SHA256.new(unsigned_string))  # 对象调用一个方法生成签名
        # base64 编码,转换为unicode表示并移除回车
        sign = encodebytes(signature).decode("utf8").replace("\n", "")
        return sign

    def _verify(self, raw_content, signature):
        # 开始计算签名
        key = self.alipay_public_key
        signer = PKCS1_v1_5.new(key)
        digest = SHA256.new()
        digest.update(raw_content.encode("utf8"))
        if signer.verify(digest, decodebytes(signature.encode("utf8"))):
            return True
        return False

    def verify(self, data, signature):
        if "sign_type" in data:
            sign_type = data.pop("sign_type")
        # 排序后的字符串
        unsigned_items = self.ordered_data(data)
        message = "&".join(u"{}={}".format(k, v) for k, v in unsigned_items)
        return self._verify(message, signature)
支付宝alipay的代码展示

三、微信推送

  首先我们需要明白的是目前的推送方式只有三个,短信推送,邮件推送,微信推送,短信推送需要去第三方专门去购买,邮件推送不需要专门去买,是最经济实惠的,但是现在看邮件的人越来越少,这个推送肯能达不到想要的效果,剩下的就是微信推送,微信的用户是最大的,所以这个推送现在也是使用的最多的。

微信的各种号

  公众号

    这个也是平时接触的最多的,有认证的公众号和未认证的公众号,认证的公众号关注的粉丝可以和公众号聊天,但是个人的公众号每天只可以发一篇文章

  服务号

    企业认证(营业执照),沙箱环境

    主动给用户发送消息(推送),用户必须关注服务号才可以推送

  企业号

    大型公司内部使用

  微信小程序

目前,微信的主要使用就是上述这几种方式,我们今天要使用的微信推送就是基于服务号展开的。

1.项目流程分析

  1.用户登录到系统,扫码关注我的服务号(这个是微信平台提供的),现在的用户并没有跟我的系统进行绑定,仅仅只是关注了服务号而已

  2.现在我们要做的就是让用户和我的系统进行绑定

    生成一个链接地址(微信的链接地址),通过链接地址生成了二维码,让用户去扫码

    用户扫描,并且确认授权,微信会向我们的回调地址发送请求,携带uid和code回来

    我们的系统拿到这个以后再去调微信的接口发送请求,携带着code过去,请求回用户的openid,其实就是微信的id

    将拿到的openid存到当前用户的数据库中,完成用户的绑定

  3.一旦用户购买了课程,给用户推送消息

    获取到acess_token,向微信的某个接口发请求,拿回token

    向微信推送消息的接口发送请求(给谁发,微信id,发送什么内容),需要携带token,并且有模板消息和普通消息

注意:

沙箱环境地址:https://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login

我们要保持配置文件和微信平台的回调地址一样,所以要在微信平台那里进行修改

网页账号     网页授权获取用户基本信息   无上限   修改 ---》》配置成自己的服务器的地址

这里我们需要用到的是request模块,具体了解见链https://www.cnblogs.com/liuqingzheng/articles/10226876.html

settings配置

# ############# 微信 ##############
WECHAT_CONFIG = {
    'app_id': 'wx6edde7a6a97e4fcd',  # 微信平台的商户的id
    'appsecret': '02d8bb38434c75d83e671047a6c7d182',   # 这个不要随便给人看
    'redirect_uri': 'http://42.56.89.12/callback/',
}

路由层配置

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^login/$', views.login),
    url(r'^index/$', views.index),
    url(r'^bind/$', views.bind),
    url(r'^bind_qcode/$', views.bind_qcode),  # 绑定消息之后返回的路由
    url(r'^callback/$', views.callback),   # 提供给微信的回调地址
    url(r'^sendmsg/$', views.sendmsg),  # 主动给用户推送消息
]

视图层

import json
import functools
import requests
from django.conf import settings
from django.shortcuts import render, redirect, HttpResponse
from django.http import JsonResponse
from app01 import models
# 沙箱环境地址:https://mp.weixin.qq.com/debug/cgi-bin/sandbox?t=sandbox/login


def index(request):
    obj = models.UserInfo.objects.get(id=1)
    return render(request, 'index.html', {'obj': obj})


def auth(func):
    def inner(request, *args, **kwargs):
        user_info = request.session.get('user_info')
        if not user_info:
            return redirect('/login/')
        return func(request, *args, **kwargs)

    return inner


def login(request):
    """
    用户登录
    :param request: 
    :return: 
    """
    # models.UserInfo.objects.create(username='luffy',password=123)

    if request.method == "POST":
        user = request.POST.get('user')
        pwd = request.POST.get('pwd')
        obj = models.UserInfo.objects.filter(username=user, password=pwd).first()
        if obj:
            # 登录成功以后将用户信息添加到session中
            request.session['user_info'] = {'id': obj.id, 'name': obj.username, 'uid': obj.uid}
            # 重定向到bind
            return redirect('/bind/')
    else:
        return render(request, 'login.html')

# 这里使用了装饰器
@auth
def bind(request):
    """
    用户登录后,关注公众号,并绑定个人微信(用于以后消息推送)
    :param request: 
    :return: 
    """
    # 直接是去到了一个绑定页面
    return render(request, 'bind.html')


@auth
def bind_qcode(request):
    """
    生成二维码
    :param request: 
    :return: 
    """
    ret = {'code': 1000}
    try:
        # 生成一个地址
        access_url = "https://open.weixin.qq.com/connect/oauth2/authorize?appid={appid}&redirect_uri={redirect_uri}&response_type=code&scope=snsapi_userinfo&state={state}#wechat_redirect"
        access_url = access_url.format(
            # 商户的appid
            appid=settings.WECHAT_CONFIG["app_id"], # 'wx6edde7a6a97e4fcd',
            # 回调地址
            redirect_uri=settings.WECHAT_CONFIG["redirect_uri"],
            # 当前登录用户的唯一id,与第三方平台交互的用户唯一id
            state=request.session['user_info']['uid'] # 为当前用户生成MD5值
        )
        ret['data'] = access_url
    except Exception as e:
        ret['code'] = 1001
        ret['msg'] = str(e)
    # access_url是微信的地址,里面包含了商户的id,真正的回调地址,以及当前的用户的uid
    # ret = {'code': 1000, 'data': access_url} /ret = {'code': 1001, 'msg': str(e)}
    return JsonResponse(ret)


def callback(request):
    """
    用户在手机微信上扫码后,微信自动调用该方法。
    用于获取扫码用户的唯一ID,以后用于给他推送消息。
    :param request: 
    :return: 
    """
    # 这是微信通过回调函数发给我们的消息
    code = request.GET.get("code")

    # 用户md5值,用户唯一id
    state = request.GET.get("state")
    print(code)

    # 获取该用户openId(用户唯一,用于给用户发送消息)  朝微信发送get请求,获取用户的微信id
    # request模块朝https://api.weixin.qq.com/sns/oauth2/access_token地址发get请求
    # 模拟浏览器发送请求
    res = requests.get(
        url="https://api.weixin.qq.com/sns/oauth2/access_token",
        # get请求里面携带的参数
        params={
            "appid": settings.WECHAT_CONFIG["app_id"],
            "secret": settings.WECHAT_CONFIG["appsecret"],
            # 带着它过去是确认我们前面刚刚登录过
            "code": code,
            "grant_type": 'authorization_code',
        }
    ).json()
    # res.data   是json格式
    # res=json.loads(res.data)
    # res是一个字典
    # 获取的到openid表示用户授权成功
    openid = res.get("openid")
    if openid:
        # 将用户的微信号存储到数据库中,完成用户的绑定
        models.UserInfo.objects.filter(uid=state).update(wx_id=openid)
        response = "<h1>授权成功 %s </h1>" % openid
    else:
        response = "<h1>用户扫码之后,手机上的提示</h1>"
    return HttpResponse(response)


# 朝用户发送推送消息的
def sendmsg(request):
    # 获取token
    def get_access_token():
        """
        获取微信全局接口的凭证(默认有效期俩个小时)
        如果不每天请求次数过多, 通过设置缓存即可
        """
        result = requests.get(
            url="https://api.weixin.qq.com/cgi-bin/token",
            params={
                "grant_type": "client_credential",
                "appid": settings.WECHAT_CONFIG['app_id'],
                "secret": settings.WECHAT_CONFIG['appsecret'],
            }
        ).json()
        # 整个result是一个大字典
        if result.get("access_token"):
            access_token = result.get('access_token')
        else:
            access_token = None
        return access_token

    # 获得成功后的token
    access_token = get_access_token()

    # 根据用户的uid拿到他的微信号,然后用这个给用户推送消息
    openid = models.UserInfo.objects.get(id=1).wx_id

    # 发送普通消息
    def send_custom_msg():
        body = {
            "touser": openid,
            "msgtype": "text",
            "text": {
                "content": 'lqz大帅哥'
            }
        }
        response = requests.post(
            url="https://api.weixin.qq.com/cgi-bin/message/custom/send",
            # 放到路径?后面的东西  params是放在get请求路劲后面?拼接的东西
            params={
                'access_token': access_token
            },
            # 这是post请求body体中的内容
            data=bytes(json.dumps(body, ensure_ascii=False), encoding='utf-8')
        )
        # 这里可根据回执code进行判定是否发送成功(也可以根据code根据错误信息)
        result = response.json()
        return result

    # 发送模板消息
    def send_template_msg():
        """
        发送模版消息
        """
        res = requests.post(
            url="https://api.weixin.qq.com/cgi-bin/message/template/send",
            params={
                'access_token': access_token
            },
            json={
                "touser": openid,
                "template_id": 'IaSe9s0rukUfKy4ZCbP4p7Hqbgp1L4hG6_EGobO2gMg',
                "data": {
                    "first": {
                        "value": "lqz",
                        "color": "#173177"
                    },
                    "keyword1": {
                        "value": "大帅哥",
                        "color": "#173177"
                    },
                }
            }
        )
        result = res.json()
        return result

    result = send_custom_msg()

    if result.get('errcode') == 0:
        return HttpResponse('发送成功')
    return HttpResponse('发送失败')
Views

模板层绑定二维码展示

{% load staticfiles %}

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<div style="width: 600px;margin: 0 auto">
    <h1>请关注个人服务号,并绑定个人用户(用于以后的消息提醒)</h1>
    <div>
        <h3>第一步:关注个人微信服务号</h3>
        <img style="height: 100px;width: 100px" src="{% static "img/0.jpeg" %}">
    </div>
    <input type="button" value="下一步【获取绑定二维码】" onclick="getBindUserQcode()">
    <div>
        <h3>第二步:绑定个人账户</h3>
        <div id="qrcode" style="width: 250px;height: 250px;background-color: white;margin: 100px auto;"></div>
    </div>
</div>
<script src="{% static "js/jquery.min.js" %}"></script>
{#qrcode 可以生成二维码 #}
<script src="{% static "js/jquery.qrcode.min.js" %}"></script>
<script src="{% static "js/qrcode.js" %}"></script>
<script>
    //你平时看到的所有二维码,都是一个地址
    function getBindUserQcode() {
        $.ajax({
            url: '/bind_qcode/',
            type: 'GET',
            success: function (result) {
                console.log(result);
                //result:{'code':1000,'data':url地址}
                //result.data 取出来的是什么?是后台生成的一个地址
                //通过js生成一个二维码图片放到div中
                $('#qrcode').empty().qrcode({text: result.data});
            }
        });
    }
</script>

</body>
</html>
templates

登录模板

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/login/" method="post">
        {% csrf_token %}
        <input type="text" name="user" placeholder="用户名">
        <input type="password" name="pwd" placeholder="密码">
        <input type="submit" value="登录">
    </form>
</body>
</html>
login
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <meta name="viewport" content="width=device-width, initial-scale=1">
</head>
<body>
    <h1>{{ obj.username }} -> {{ obj.wx_id }}</h1>
</body>
</html>
index

模型表层展示

import hashlib
from django.db import models

class UserInfo(models.Model):
    username = models.CharField("用户名", max_length=64, unique=True)
    password = models.CharField("密码", max_length=64)
    uid = models.CharField(verbose_name='个人唯一ID',max_length=64, unique=True)
    wx_id = models.CharField(verbose_name="微信ID", max_length=128, blank=True, null=True, db_index=True)

    def save(self, *args, **kwargs):
        # 创建用户时,为用户自动生成个人唯一ID
        if not self.pk:
            m = hashlib.md5()
            m.update(self.username.encode(encoding="utf-8"))
            self.uid = m.hexdigest()
        super(UserInfo, self).save(*args, **kwargs)

静态文件主要是你个人的一些文件和js的配置,这里则不做一一赘述。

 

  

 

 

  

posted @ 2019-07-14 17:03  mcc61  阅读(912)  评论(0编辑  收藏  举报