コード例 #1
0
def mp_send_template_message(app_id,
                             touser,
                             template_id,
                             data,
                             url=None,
                             mini_program=None):
    """
    发送公众号模板消息

    Params:
        app_id         是   微信应用 app_id
        touser         是   用户 ID 。 就是你收到的 `Message` 的 source
        template_id    是   模板 ID。在公众平台线上模板库中选用模板获得
        data           是   模板消息数据
        url            否   链接地址
        mini_program   否   跳小程序所需数据, 如:`{'appid': 'appid', 'pagepath': 'index?foo=bar'}`
    """
    if app_id not in settings.WECHAT_APP_MAP:
        return

    data = data if (data and isinstance(data, dict)) else {}
    try:
        appsecret = settings.WECHAT_APP_MAP[app_id]['appsecret']
        session = RedisStorage(get_redis_connection())\
            if settings.CACHES['default']['BACKEND'] == 'django_redis.cache.RedisCache'\
                else MemoryStorage()
        client = WeChatClient(app_id, appsecret, session=session)

        return client.message.send_template(touser,
                                            template_id,
                                            data,
                                            url=url,
                                            mini_program=mini_program)
    except Exception as e:
        logger.error(f'mp_send_template_error:{e}')
コード例 #2
0
ファイル: auth.py プロジェクト: tkliuxing/dj-usercenter
 def validate(self, data):
     phone, pa = data['phone'], data['phone_access']
     try:
         access = PhoneAccess.objects.get(phone=phone, phone_access=pa)
         if phone != '17704818161':
             access.delete()
     except PhoneAccess.DoesNotExist:
         raise ValidationError('验证码错误')
     try:
         user = User.objects.get(username=phone)
     except User.DoesNotExist:
         raise ValidationError('用户不存在')
     code = data['code']
     redis_client = Redis.from_url(getattr(settings, 'REDIS_URL'))
     session_interface = RedisStorage(redis_client, prefix="wechatpy")
     appid = getattr(settings, 'WXA_APPID')
     secret = getattr(settings, 'WXA_SECRET')
     if not appid or not secret:
         raise ValidationError('微信小程序未配置')
     wechat_client = WeChatClient(appid, secret, session=session_interface)
     try:
         wx_data = wechat_client.wxa.code_to_session(code)
     except WeChatClientException:
         raise ValidationError('code已使用')
     users = User.objects.exclude(username=phone).filter(
         wechart_oid=wx_data['openid'])
     if users:
         raise ValidationError('其它用户已绑定此微信,请更换微信号后进行绑定')
     user.wechart_oid = wx_data['openid']
     user.save()
     return data
コード例 #3
0
    def _init_session(self, config):
        if config['WECHAT_SESSION_TYPE'] == 'redis':
            from wechatpy.session.redisstorage import RedisStorage
            from redis import Redis

            if config.get('WECHAT_SESSION_REDIS_URL'):
                redis = Redis.from_url(config['WECHAT_SESSION_REDIS_URL'])
            else:
                redis = Redis(host=config.get('WECHAT_SESSION_REDIS_HOST',
                                              'localhost'),
                              port=config.get('WECHAT_SESSION_REDIS_PORT',
                                              6379),
                              db=config.get('WECHAT_SESSION_REDIS_DB', 0),
                              password=config.get('WECHAT_SESSION_REDIS_PASS',
                                                  None))
            prefix = config['WECHAT_SESSION_PREFIX']
            self._redis_prefix = prefix
            self._redis = redis
            session_interface = RedisStorage(redis, prefix=prefix)

        elif config['WECHAT_SESSION_TYPE'] == 'memcached':
            from wechatpy.session.memcachedstorage import MemcachedStorage
            mc = self._get_mc_client(config['WECHAT_SESSION_MEMCACHED'])
            session_interface = MemcachedStorage(
                mc, prefix=config['WECHAT_SESSION_PREFIX'])

        elif config['WECHAT_SESSION_TYPE'] == 'leancloud':
            from .storage import LeanCloudStorage
            session_interface = LeanCloudStorage()

        else:
            from wechatpy.session.memorystorage import MemoryStorage
            session_interface = MemoryStorage()
        return session_interface
コード例 #4
0
ファイル: test_session.py プロジェクト: zhy0313/wechatpy
    def test_redis_session_storage_init(self):
        from redis import Redis
        from wechatpy.session.redisstorage import RedisStorage

        redis = Redis()
        session = RedisStorage(redis)
        client = WeChatClient(self.app_id, self.secret, session=session)
        self.assertTrue(isinstance(client.session, RedisStorage))
コード例 #5
0
ファイル: __init__.py プロジェクト: imfht/flaskapps
    def init_app(self, app):
        self.app = app

        config = app.config
        config.setdefault('WECHAT_APPID', None)
        config.setdefault('WECHAT_SECRET', None)
        config.setdefault('WECHAT_TYPE', 0)
        config.setdefault('WECHAT_SESSION_TYPE', None)
        config.setdefault('WECHAT_SESSION_PREFIX', 'flask-wechatpy')
        config.setdefault('WECHAT_AUTO_RETRY', True)
        config.setdefault('WECHAT_TIMEOUT', None)

        assert config['WECHAT_APPID'] is not None
        assert config['WECHAT_SECRET'] is not None

        if config['WECHAT_TYPE'] == 0:
            from wechatpy import WeChatClient
        else:
            from wechatpy.enterprise import WeChatClient

        if config['WECHAT_SESSION_TYPE'] == 'redis':
            from wechatpy.session.redisstorage import RedisStorage
            from redis import Redis
            if config.get('WECHAT_SESSION_REDIS_URL'):
                redis = Redis.from_url(config['WECHAT_SESSION_REDIS_URL'])
            else:
                redis = Redis(host=config.get('WECHAT_SESSION_REDIS_HOST',
                                              'localhost'),
                              port=config.get('WECHAT_SESSION_REDIS_PORT',
                                              6379),
                              db=config.get('WECHAT_SESSION_REDIS_DB', 0),
                              password=config.get('WECHAT_SESSION_REDIS_PASS',
                                                  None))
            session_interface = RedisStorage(
                redis, prefix=config['WECHAT_SESSION_PREFIX'])
        elif config['WECHAT_SESSION_TYPE'] == 'memcached':
            from wechatpy.session.memcachedstorage import MemcachedStorage
            mc = self._get_mc_client(config['WECHAT_SESSION_MEMCACHED'])
            session_interface = MemcachedStorage(
                mc, prefix=config['WECHAT_SESSION_PREFIX'])
        elif config['WECHAT_SESSION_TYPE'] == 'shove':
            pass
        else:
            session_interface = None

        self._wechat_client = WeChatClient(
            config['WECHAT_APPID'],
            config['WECHAT_SECRET'],
            session=session_interface,
            timeout=config['WECHAT_TIMEOUT'],
            auto_retry=config['WECHAT_AUTO_RETRY'],
        )

        if not hasattr(app, 'extensions'):
            app.extensions = {}
        app.extensions['wechatpy'] = self
コード例 #6
0
    def __init__(self, appid, secret, redis_client=None):
        session_interface = None
        if redis_client:
            session_interface = RedisStorage(redis_client, prefix="wechatpy")
        client = WeChatClient(appid, secret, session=session_interface)

        self.menu = wechatMenu(client)
        self.qrcode = wechatQrcode(client)
        self.send = wechatSend(client)
        self.user = wechatUser(client)
コード例 #7
0
 def set_session(self, redis=None, shove=None, mc=None, prefix="wechatpy"):
     if redis is not None:
         from wechatpy.session.redisstorage import RedisStorage
         self.session = RedisStorage(redis, prefix)
     elif shove is not None:
         from wechatpy.session.shovestorage import ShoveStorage
         self.session = ShoveStorage(shove, prefix)
     elif mc is not None:
         from wechatpy.session.memcachedstorage import MemcachedStorage
         self.session = MemcachedStorage(mc, prefix)
コード例 #8
0
 def __init__(
     self,
     msg,
 ):
     self.msg = msg
     self.path = current_app.config['CODE_PATH'],
     redis_client = Redis.from_url(current_app.config['REDIS_STORAGE'])
     session_interface = RedisStorage(redis_client, prefix="ACCESS_TOKEN")
     self.client = WeChatClient(current_app.config['APP_ID'],
                                current_app.config['SECRET'],
                                session=session_interface)
コード例 #9
0
ファイル: test_session.py プロジェクト: zhy0313/wechatpy
    def test_redis_session_storage_access_token(self):
        from redis import Redis
        from wechatpy.session.redisstorage import RedisStorage

        redis = Redis()
        session = RedisStorage(redis)
        client = WeChatClient(self.app_id, self.secret, session=session)
        with HTTMock(wechat_api_mock):
            token = client.fetch_access_token()
            self.assertEqual('1234567890', token['access_token'])
            self.assertEqual(7200, token['expires_in'])
            self.assertEqual('1234567890', client.access_token)
コード例 #10
0
 def _get_wechatclient():
     app_id = current_app.config.get('app_id')
     secret = current_app.config.get('secret')
     redirect_uri = current_app.config.get('redirect_uri')
     redis_url = current_app.config.get('REDIS_HOST')
     redis_port = current_app.config.get('REDIS_PORT')
     redis_db = current_app.config.get('REDIS_DB')
     redis_client = redis.Redis.from_url('redis://{}:{}/{}'.format(
         redis_url, redis_port, redis_db))
     session_interface = RedisStorage(redis_client, prefix="wechatpy")
     wechatclient = WeChatClient(app_id, secret, session=session_interface)
     return wechatclient
コード例 #11
0
    def test_client_expires_at_consistency(self):
        from redis import Redis
        from wechatpy.session.redisstorage import RedisStorage

        redis = Redis()
        session = RedisStorage(redis)
        client1 = WeChatClient(self.app_id, self.secret, session=session)
        client2 = WeChatClient(self.app_id, self.secret, session=session)
        assert client1.expires_at == client2.expires_at
        expires_at = time.time() + 7200
        client1.expires_at = expires_at
        assert client1.expires_at == client2.expires_at == expires_at
コード例 #12
0
ファイル: wechat.py プロジェクト: philosquare/zju_wechat
 def __init__(self):
     self.redis_client = Redis(host=redis_host, password=redis_password)
     self.session_interface = RedisStorage(self.redis_client,
                                           prefix="wechatpy")
     self.wechat_client = WeChatClient(appid,
                                       secret,
                                       session=self.session_interface)
     self.template_id = {
         Instrument.F20: template_id_remind_f20,
         Instrument.FIB: template_id_remind_fib
     }
     self.mysql = pymysql.connect(host=mysql_host,
                                  password=mysql_password,
                                  db='wechat_tem',
                                  charset='utf8',
                                  autocommit=True)
コード例 #13
0
ファイル: auth.py プロジェクト: tkliuxing/dj-usercenter
 def validate(self, data):
     code = data['code']
     redis_client = Redis.from_url(getattr(settings, 'REDIS_URL'))
     session_interface = RedisStorage(redis_client, prefix="wechatpy")
     appid = getattr(settings, 'WXA_APPID')
     secret = getattr(settings, 'WXA_SECRET')
     if not appid or not secret:
         raise ValidationError('微信小程序未配置')
     wechat_client = WeChatClient(appid, secret, session=session_interface)
     try:
         data = wechat_client.wxa.code_to_session(code)
     except WeChatClientException:
         raise ValidationError('code已使用')
     try:
         User.objects.get(wechart_oid=data['openid'])
     except User.DoesNotExist:
         raise ValidationError('用户不存在')
     return data
コード例 #14
0
    def send_wechat_template(self, data):
        """ template
        {{first.DATA}}
        title1:{{keyword1.DATA}}
        title2:{{keyword2.DATA}}
        title3:{{keyword3.DATA}}
        {{remark.DATA}}
        """
        if not wechat_available:
            result_json = {"errcode": 40002}
            return result_json

        if redis_available and self.redis != "":
            redis_client = Redis.from_url(self.redis)
            session_interface = RedisStorage(redis_client, prefix="wechatpy")
            wechat_client = WeChatClient(self.appid,
                                         self.secret,
                                         session=session_interface)
        else:
            wechat_client = WeChatClient(self.appid, self.secret)
        for user in self.users.split(","):
            result_json = wechat_client.message.send_template(
                user, self.template, data)
        return result_json
コード例 #15
0
gconf = yaml.load(file(ospath + '/gconf.yml', 'r'))[run_mode]
gconf['uptime'] = time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
gconf['run_mode'] = run_mode

srv = yaml.load(file(ospath + '/srv.yml', 'r'))[run_mode]

wx = yaml.load(file(ospath + '/wx.yml', 'r'))[run_mode]

errorDesc = yaml.load(file(ospath + '/errorDesc.yml', 'r'))

upFile = upyun.UpYun(gconf['up_file_bucket'],
                     gconf['up_file_uname'],
                     gconf['up_file_pwd'],
                     timeout=30,
                     endpoint=upyun.ED_AUTO)
msgDict = {}

pool = redis.ConnectionPool(**srv['redis'])
rdb = redis.StrictRedis(connection_pool=pool)

mdb = MongoClient(srv['mongo']['host'], srv['mongo']['port'])
mdb.admin.authenticate(srv['mongo']['uname'],
                       srv['mongo']['pwd'],
                       mechanism='SCRAM-SHA-1')
mdb = mdb[srv['mongo']['db']]

wxclient = WeChatClient(wx['APP_ID'],
                        wx['APP_SECRET'],
                        session=RedisStorage(rdb))
コード例 #16
0
    def init(self, env):
        dbname = env.cr.dbname
        global WxEnvDict
        if dbname in WxEnvDict:
            del WxEnvDict[dbname]
        WxEnvDict[dbname] = self

        try:
            config = env['wx.config'].sudo().get_cur()
            action = config.action
        except:
            import traceback
            traceback.print_exc()
            action = None
        if action:
            self.subscribe_auto_msg = config.action.get_wx_reply()

        Param = env['ir.config_parameter'].sudo()
        self.wx_token = Param.get_param('wx_token') or ''
        self.wx_appid = Param.get_param('wx_appid') or ''
        self.wx_AppSecret = Param.get_param('wx_AppSecret') or ''
        self.server_url = Param.get_param('server_url') or ''
        self.session_storage = Param.get_param('session_storage') or ''
        self.wxclient.config["APP_ID"] = self.wx_appid
        self.wxclient.config["APP_SECRET"] = self.wx_AppSecret
        self.wxclient.config["server_url"] = self.server_url

        if not self.session_storage:
            session_storage = MemoryStorage()
            _logger.info("启用MemoryStorage")
        else:
            _logger.info("启用RedisStorage%s" % self.wx_appid)
            db = redis.Redis(host=self.session_storage, port=6379)
            session_storage = RedisStorage(db, prefix=self.wx_appid)
        try:
            #  获取以前的token是否需要获取新的Token AccessToken
            self.wxclient.session = session_storage
            # self.wxclient._token = session_storage.get(self.access_token_key)
            _ = self.wxclient.token
        except Exception as e:
            print(e)
            import traceback
            traceback.print_exc()
            _logger.error(u'初始化微信客户端token失败,请在微信对接配置中填写好相关信息!')

        robot = WeRoBot(token=self.wx_token,
                        enable_session=True,
                        logger=_logger,
                        session_storage=session_storage)
        enable_pretty_logging(robot.logger)
        self.robot = robot
        try:
            wechatpy_client = WeChatClient(self.wx_appid,
                                           self.wx_AppSecret,
                                           access_token=self.wxclient.token,
                                           session=session_storage)
            self.wechatpy_client = wechatpy_client
        except Exception as e:
            print(e)
            _logger.error("加载微信token错误。")
        try:
            users = env['wx.user'].sudo().search([('last_uuid', '!=', None)])
            for obj in users:
                if obj.last_uuid_time:
                    self.recover_uuid(
                        obj.openid, obj.last_uuid,
                        fields.Datetime.from_string(obj.last_uuid_time))
        except:
            env.cr.rollback()
            import traceback
            traceback.print_exc()
        print('wx client init: %s %s' % (self.OPENID_UUID, self.UUID_OPENID))
コード例 #17
0
ファイル: wechat.py プロジェクト: ababilinski/UGATIT-s2a
# -*- coding: utf-8 -*-
import os
from wechatpy.client import WeChatClient
import requests
from wechatpy.session.redisstorage import RedisStorage
from redis import Redis


__redis_client = Redis.from_url('redis://127.0.0.1:6379/0')
__session_interface = RedisStorage(
    __redis_client,
    prefix='s2a'
)

wechat_client = WeChatClient(
                appid=os.environ.get('APP_ID'), 
                secret=os.environ.get('APP_SECRET'),
                session=__session_interface
)


コード例 #18
0
ファイル: main.py プロジェクト: dzxs/sanic-jssdk-stuff
import time

from sanic import Sanic
from sanic.response import json
from sanic_cors import CORS, cross_origin
from redis import Redis
from wechatpy import WeChatClient
from wechatpy.session.redisstorage import RedisStorage
from wechatpy.utils import random_string

# wechatpy
redis_client = Redis.from_url("redis://127.0.0.1:6379/0")
session_interface = RedisStorage(redis_client, prefix="wechatpy")
appid = "wx864c69fe65dd3965"
secret = "61e14f509405ddb041b5c08c552691ee"
client = WeChatClient(appid=appid, secret=secret, session=session_interface)

app = Sanic()
CORS(app)


@app.route("/")
async def test(request):
    return json({"hello": "world"})


@app.route("/jssdk_config")
async def jssdk_config(request):
    url = request.headers.get("referer")
    ticket = client.jsapi.get_jsapi_ticket()
    timestamp = int(time.time())
コード例 #19
0
from django.conf import settings
from django.core.cache import cache
from wechatpy.client import WeChatClient
from wechatpy.client.api import WeChatWxa
from wechatpy.session.redisstorage import RedisStorage
from wechatpy.session.memorystorage import MemoryStorage

from django_redis import get_redis_connection

session = (
    RedisStorage(get_redis_connection())
    if settings.CACHES["default"]["BACKEND"] == "django_redis.cache.RedisCache"
    else MemoryStorage()
)


def wrap(api, app_id, app_secret=None):
    return api(
        client=WeChatClient(
            appid=app_id,
            secret=app_secret or settings.WECHAT_APP_MAP[app_id]["appsecret"],
            session=session,
        )
    )


def wxa(app_id, app_secret=None):
    return wrap(WeChatWxa, app_id=app_id, app_secret=app_secret)


def wechat_client(app_id, app_secret=None):
コード例 #20
0
from __future__ import absolute_import, unicode_literals
from wechatpy import WeChatOAuth
from flask import request, abort, jsonify
from wechatpy.exceptions import *
from wechatpy.session.redisstorage import RedisStorage
from halo import redis_client, app
from wechatpy.utils import json

TOKEN = app.config['TOKEN']
AES_KEY = app.config['AES_KEY']
APPID = app.config['APPID']
APPSECRET = app.config['APPSECRET']

redirect_uri = 'http://m.ayhalo.com'

oauth_session = RedisStorage(redis_client, prefix="oauth")

oauth = WeChatOAuth(APPID,
                    APPSECRET,
                    redirect_uri,
                    scope='snsapi_userinfo',
                    state='halo')


def get_init():
    code = request.args.get('code', '')

    token = oauth.fetch_access_token(code)
    openid = token['openid']
    access_token = token['access_token']
    oauth_session.set('access_token', token['access_token'], 7000)
コード例 #21
0
ファイル: we_client.py プロジェクト: qcyb/restful_server
class WeClient(object):
    we_client = WeChatClient(appid=settings.MP_APP_ID,
                             secret=settings.MP_APP_SECRET,
                             session=RedisStorage(redis_client,
                                                  prefix='wechat'))
    ACCOUNT_VIEW_BTN_EVENT = 'ACCOUNT_VIEW_BTN_EVENT'  # 账户中心
    CUSTOMER_SERVICE_BTN_EVENT = 'CUSTOMER_SERVICE_BTN_EVENT'  # 联系客服
    ACCOUNT_VIEW_URI = f'https://open.weixin.qq.com/connect/oauth2/authorize?appid={settings.MP_APP_ID}' \
                       f'&redirect_uri={settings.MP_HOST}/&response_type=code&scope=snsapi_userinfo'
    PLATFORM_VIEW_URI = f'https://open.weixin.qq.com/connect/oauth2/authorize?appid={settings.MP_APP_ID}' \
                        f'&redirect_uri={settings.MP_HOST}/platform&response_type=code&scope=snsapi_userinfo'
    IOS_VIEW_URI = f'https://open.weixin.qq.com/connect/oauth2/authorize?appid={settings.MP_APP_ID}' \
                   f'&redirect_uri={settings.MP_HOST}/ios&response_type=code&scope=snsapi_userinfo'
    ANDROID_VIEW_URI = f'https://open.weixin.qq.com/connect/oauth2/authorize?appid={settings.MP_APP_ID}' \
                       f'&redirect_uri={settings.MP_HOST}/android&response_type=code&scope=snsapi_userinfo'

    @classmethod
    def create_mp_menu(cls):
        if not settings.ENV.is_production():
            return

        # 创建公众号-自定义菜单: https://mp.weixin.qq.com/wiki?t=resource/res_main&id=mp1421141013
        menu_data = {
            'button': [{
                'type': 'click',
                'name': '账号中心',
                'key': cls.ACCOUNT_VIEW_BTN_EVENT,
            }, {
                'name':
                'WIFI连接教程',
                'sub_button': [
                    {
                        'type': 'view',
                        'name': '上网教程 (苹果手机)',
                        'url': cls.IOS_VIEW_URI,
                    },
                    {
                        'type': 'view',
                        'name': '上网教程 (安卓手机)',
                        'url': cls.ANDROID_VIEW_URI,
                    },
                    {
                        'type': 'click',
                        'name': '联系客服',
                        'key': cls.CUSTOMER_SERVICE_BTN_EVENT,
                    },
                    {
                        'type': 'view',
                        'name': '房东二维码 (仅房东用)',
                        'url': cls.PLATFORM_VIEW_URI,
                    },
                ]
            }]
        }
        cls.we_client.menu.create(menu_data)
        return

    @classmethod
    def create_qrcode(cls,
                      scene_str: str,
                      expire_seconds: int = 30,
                      is_permanent=False):
        """
        https://developers.weixin.qq.com/doc/offiaccount/Account_Management/Generating_a_Parametric_QR_Code.html
        :param scene_str:
        :param expire_seconds:
        :param is_permanent:
        :return: {"ticket":"gQH47joAAAAAAAAAASxod2G3sUw==","expire_seconds":60,"url":"http://weixin.qq.com/q/kZgfwMTm72WWPkovabbI"}
                    ticket:  获取的二维码ticket,凭借此ticket可以在有效时间内换取二维码。
                    expire_seconds:  该二维码有效时间,以秒为单位。 最大不超过2592000(即30天)。
                    url:  二维码图片解析后的地址,开发者可根据该地址自行生成需要的二维码图片
        """
        assert isinstance(scene_str, str)
        data = {
            'expire_seconds': expire_seconds,
            'action_name':
            'QR_LIMIT_STR_SCENE' if is_permanent else 'QR_STR_SCENE',
            'action_info': {
                'scene': {
                    'scene_str': scene_str
                },
            }
        }
        return cls.we_client.qrcode.create(data)
コード例 #22
0
        env.setdefault(k, v)
    redis_host = env["REDIS_HOST"]
    redis_port = int(env["REDIS_PORT"])
    redis_pwd = env["REDIS_PWD"]
    wechat_corp_id = env["WECHAT_CORP_ID"]
    wechat_secret = env["WECHAT_SECRET"]
    wechat_crypto_token = env['WECHAT_CRYPTO_TOKEN']
    wechat_crypto_encoding_aes_key = env['WECHAT_CRYPTO_AES_KEY']
    wechat_invite_code = env['WECHAT_INVITE_CODE']
    wechat_create_menu = distutils.util.strtobool(env['WECHAT_CREATE_MENU'])
    agent_id = env['AGENT_ID']
    image_id = env['IMAGE_ID']
    debug = distutils.util.strtobool(env['DEBUG'])
    logging.basicConfig(level=logging.DEBUG if debug else logging.INFO)
    for i in [redis_host, redis_port, redis_pwd, wechat_corp_id, wechat_secret,
              wechat_crypto_token, wechat_crypto_encoding_aes_key, agent_id]:
        if i == 'set_it':
            logging.error(env.items())
            logging.error('部分变量未设置,请检查你的变量设置是否正确。')
            time.sleep(30)
            exit(-1)
    if wechat_create_menu:
        create_menu()
    r = redis.Redis(host=redis_host, port=redis_port, db=0, password=redis_pwd)
    crypto = WeChatCrypto(token=wechat_crypto_token, encoding_aes_key=wechat_crypto_encoding_aes_key,
                          corp_id=wechat_corp_id)
    client = WeChatClient(corp_id=wechat_corp_id, secret=wechat_secret, session=RedisStorage(r))
    # 启用京东登录事件循环
    jd_qrcode.start_loop()
    run()
コード例 #23
0
def session_interface():
    return  RedisStorage(
        Redis.redis_client(),
        prefix="wechatpy"
    )
コード例 #24
0
# encoding: utf-8
from __future__ import absolute_import, unicode_literals

from django.conf import settings
from django.core.files.uploadedfile import InMemoryUploadedFile
from redis import Redis
from six import BytesIO
from wechatpy import WeChatClient
from wechatpy.crypto import WeChatWxaCrypto
from wechatpy.session.redisstorage import RedisStorage

redis_client = Redis.from_url(settings.REDIS_CACHE_URL)
wechat = WeChatClient(settings.WECHAT_APPID,
                      settings.WECHAT_APPSECRET,
                      session=RedisStorage(redis_client,
                                           prefix="wechat_session::%s" %
                                           settings.WECHAT_APPID))


def decrypt_message(session_key, iv, encrypted_data):
    crypto = WeChatWxaCrypto(session_key, iv, settings.WECHAT_APPID)
    return crypto.decrypt_message(encrypted_data)


def get_wxa_code_unlimited_file(file_name, scene, **kwargs):
    file = BytesIO()
    kw = dict()
    for k in ('width', 'auto_color', 'line_color', 'page', 'is_hyaline'):
        if k in kwargs:
            kw[k] = kwargs[k]
    content = wechat.wxa.get_wxa_code_unlimited(scene, **kw)
コード例 #25
0
def init_Wechat():
    session_inferface = RedisStorage(redis_client, prefix="weixin")

    client = WeChatClient(APPID, APPSECRET, session=session_inferface)
    return client