manyi/apps/web/merchant/utils.py

# coding=utf-8

import datetime
import base64
import json
import logging
import requests
from mongoengine import DoesNotExist
from typing import TYPE_CHECKING, Optional

from apps.web.core.bridge.wechat.v3api import WechatApiProxy
from apps.web.core.exceptions import MerchantError
from apps.web.core.models import WechatServiceProvider, JDAggrePayApp, AliApp
from apps.web.core.utils import async_operation_no_catch
from apps.web.dealer.models import Dealer
from apps.web.merchant.exceptions import JdOpenParamsError
from apps.web.merchant.constant import ProductStatus, MerchantStatus, JdOpenMerchantType, JdOpenAccountType, JdOpenAuditStatus, JdOpenProductType, AuthStatus, ALI_PAY_QR_CODE
from apps.web.merchant.models import MerchantSourceInfo, JDOpenApplyInfo, MerchantAgent
from library.jdopen.constants import OPEN_SECRET_KEY, OPEN_ACCESS_KEY
from library.jdopen.exceptions import JdOpenException
from library.jdopen.client import JdOpenMerchantClient
from library.jdpsi.client import JdPsiMerchantClient
from library.jdpsi.exceptions import JdPsiException


if TYPE_CHECKING:
    from apps.web.agent.models import Agent
    from apps.web.merchant.models import Attach


logger = logging.getLogger(__name__)


# 信号触发函数


def upload_merchant_to_jd(sender, merchantId, **kwargs):   # type: (Optional[MerchantSourceInfo, JDOpenApplyInfo], str, dict) -> None
    # 先查找到商户
    logger.info("[upload_merchant_to_jd] start to upload data to jd merchant, merchantId = {}".format(merchantId))
    try:
        merchant = sender.objects.get(id=merchantId)
    except DoesNotExist:
        logger.error("[upload_merchant_to_jd] find merchant error not exist!, merchantId = {}".format(merchantId))
        return

    proxy = MerchantApplyProxy(merchant)
    async_operation_no_catch(proxy.submit_data)


def upload_merchant_to_auth(sender, merchantId, **kwargs):    # type: (Optional[MerchantSourceInfo, JDOpenApplyInfo], str, dict) -> None
    """
    上传商户的实名确认信息 包括支付宝的和微信的
    """
    logger.info("[upload_merchant_to_auth] start to upload data to wechat, merchantId = {}".format(merchantId))

    try:
        merchant = sender.objects.get(id=merchantId)
    except DoesNotExist:
        logger.error("[upload_merchant_to_auth] find merchant error not exist!, merchantId = {}".format(merchantId))
        return

    # 分别提交支付宝以及微信的实名认证资料
    proxy = MerchantApplyProxy(merchant)
    async_operation_no_catch(proxy.submit_wechat)
    async_operation_no_catch(proxy.submit_ali)


def create_psi_product(sender, merchantId, **kwargs):
    logger.info("[create_psi_product] start to create psi merchant product, merchantId = {}".format(merchantId))

    try:
        merchant = sender.objects.get(id=merchantId)
    except DoesNotExist:
        logger.error("[create_psi_product] find merchant error not exist!, merchantId = {}".format(merchantId))
        return

    applier = JdPsiMerchantApplier(merchant, get_psi_client())
    async_operation_no_catch(applier.create_product)


def create_settle(sender, merchantId, **kwargs):        # type: (Optional[MerchantSourceInfo, JDOpenApplyInfo], str, dict) -> None
    """
    京东 open 创建商户
    """
    logger.info("[create_settle] start to create open merchant settle account, merchantId = {}".format(merchantId))

    try:
        merchant = sender.objects.get(id=merchantId)
    except DoesNotExist:
        logger.error("[create_settle] find merchant error not exist!, merchantId = {}".format(merchantId))
        return

    applier = JdOpenMerchantApplier(merchant, get_open_client())
    async_operation_no_catch(applier.create_settle)


def create_shop(sender, merchantId, **kwargs):          # type: (Optional[MerchantSourceInfo, JDOpenApplyInfo], str, dict) -> None
    """
    京东 open 创建商店
    """
    logger.info("[create_shop] start to create open shop, merchantId = {}".format(merchantId))

    try:
        merchant = sender.objects.get(id=merchantId)
    except DoesNotExist:
        logger.error("[create_shop] find merchant error not exist!, merchantId = {}".format(merchantId))
        return

    applier = JdOpenMerchantApplier(merchant, get_open_client())
    async_operation_no_catch(applier.create_shop)


def upload_attaches(sender, merchantId, **kwargs):          # type: (Optional[MerchantSourceInfo, JDOpenApplyInfo], str, dict) -> None
    """
    京东 open 上传附件
    """
    logger.info("[upload_attaches] start to upload open merchant attaches, merchantId = {}".format(merchantId))

    try:
        merchant = sender.objects.get(id=merchantId)
    except DoesNotExist:
        logger.error("[upload_attaches] find merchant error not exist!, merchantId = {}".format(merchantId))
        return

    applier = JdOpenMerchantApplier(merchant, get_open_client())
    async_operation_no_catch(applier.upload_attaches)


def complete_customer(sender, merchantId, **kwargs):            # type: (Optional[MerchantSourceInfo, JDOpenApplyInfo], str, dict) -> None
    """
    京东 open 完成报单
    """
    logger.info("[complete_customer] start to complete open merchant, merchantId = {}".format(merchantId))

    try:
        merchant = sender.objects.get(id=merchantId)
    except DoesNotExist:
        logger.error("[complete_customer] find merchant error not exist!, merchantId = {}".format(merchantId))
        return

    applier = JdOpenMerchantApplier(merchant, get_open_client())
    async_operation_no_catch(applier.complete)


def confirm_customer(sender, merchantId, **kwargs):             # type: (Optional[MerchantSourceInfo, JDOpenApplyInfo], str, dict) -> None
    """
    京东 open 报单确认
    """
    logger.info("[confirm_customer] start to confirm open merchant, merchantId = {}".format(merchantId))

    try:
        merchant = sender.objects.get(id=merchantId)
    except DoesNotExist:
        logger.error("[confirm_customer] find merchant error not exist!, merchantId = {}".format(merchantId))
        return

    applier = JdOpenMerchantApplier(merchant, get_open_client())
    async_operation_no_catch(applier.confirm)


# 功能辅助函数


def get_file(url):
    res = requests.get(url)
    return res.content


def get_location_by_area(province, city, district, addr, webKey="109f7b4b81698f345f24aa3dc6684924"):
    """
    根据地址获取经纬度
    """
    logger.info("[get_location_by_area] province = {}, city = {}, district = {}, addr = {}".format(province, city, district, addr))

    url = "https://restapi.amap.com/v3/geocode/geo?address={}{}{}{}&key={}".format(province, city, district, addr, webKey)
    try:
        result = requests.get(url).json()
    except Exception as e:
        logger.error("[get_location_by_area] error = {}, province = {}, city = {}, district = {}, addr = {}".format(e, province, city, district, addr))
        return "0.000000", "0.000000"

    if "status" not in result or result["status"] != "1":
        return "0.000000", "0.000000"

    geocode = result["geocodes"][0]
    lng, lat = geocode["location"].split(",")

    return lng, lat


def get_wechat_proxy():
    provider = WechatServiceProvider.objects.get(mchid="398254625")  # type: WechatServiceProvider
    return WechatApiProxy(provider)  # type: WechatApiProxy


def get_open_client():
    openClient = JdOpenMerchantClient(OPEN_ACCESS_KEY, OPEN_SECRET_KEY)
    return openClient


def get_psi_client():
    psiClient = JdPsiMerchantClient()
    return psiClient


def get_ali_client():
    app = AliApp.objects.get(appid="2021001191645419")  # type: AliApp
    return app.client


def query_merchant_settle(merchantOwner, st, et):    # type: (Dealer, datetime.datetime, datetime.datetime) -> dict
    """
    查询商户的结算信息 只查询1天的 （商户拥有者可能是代理商、经销商）
    """
    merchant = MerchantSourceInfo.get_source_record(merchantOwner)     # type: MerchantSourceInfo

    if not merchant.merchantNo:
        app = merchantOwner.jd_env_pay_app()  # type: JDAggrePayApp
        agentNo = MerchantAgent.default_merchant_agent
        merchantNo = app.merchant_no
    else:
        agentNo = merchant.agentNo
        merchantNo = merchant.merchantNo

    startTime = datetime.datetime.strftime(st, "%Y-%m-%d")
    endTime = datetime.datetime.strftime(et, "%Y-%m-%d")
    psiClient = get_psi_client()
    result = psiClient.query_settle(agentNo, startTime, endTime, merchantNo=merchantNo)

    return result


def query_sub_merchantId(document, openClient):    # type: (Optional[None, JDOpenApplyInfo], JdOpenMerchantClient) -> Optional[None, JDOpenApplyInfo]
    """
    查询 jdopen 的子商户编号 （微信 支付宝）
    """
    # 首先查询 微信的子商编
    data = {
        "customerNum": document.customerNum,
        "payProduct": str(JdOpenProductType.WX.value)
    }

    try:
        result = openClient.support.get_product_customer(**data)
    except JdOpenException as je:
        logger.error("[query_sub_merchantId] duo_la_bao merchant <{}> query audit result error = {} ".format(document, je))
        return

    # 获取到了微信的子商编号
    for item in result["data"]:
        if item["status"] == "OPEN":
            subMerchantId = item["subCustomerNum"]
            break
    else:
        subMerchantId = ""

    logger.info("[query_sub_merchantId] duo_la_bao merchant <{}> query sub merchantId subMerchantId = {} ".format(document, subMerchantId))

    data["payProduct"] = str(JdOpenProductType.ALI.value)
    try:
        result = openClient.support.get_product_customer(**data)
    except JdOpenException as je:
        logger.error("[query_sub_merchantId] duo_la_bao merchant <{}> query audit result error = {} ".format(document, je))
        return

    for item in result["data"]:
        if item["status"] == "OPEN":
            subAliMerchantId = item["subCustomerNum"]
            break
    else:
        subAliMerchantId = ""

    logger.info("[query_sub_merchantId] duo_la_bao merchant <{}> query sub merchantId subAliMerchantId = {} ".format(document, subAliMerchantId))

    # 更新商户编号到 文档 然后等待进一步的资料
    return document.update_sub_merchant(subMerchantId=subMerchantId, subAliMerchantId=subAliMerchantId)


def get_merchant_by_version(owner, version):
    if version == "v2":
        return JDOpenApplyInfo.get_merchant_by_owner(owner)
    else:
        return MerchantSourceInfo.get_source_record(owner)


def update_channels_info(merchant):
    """
    获取自研商户的子商编
    新增获取支付宝的子商户编号
    """
    logger.info("[update_channels_info] ownerId = {}".format(merchant.ownerId))

    # 如果存在就不要去获取了
    if merchant.wxSource.subMerchantId and merchant.wxSource.subAliMerchantId:
        logger.info("[update_channels_info] ownerId = {}, channels has been ready<wechat: {}; ali: {}>".format(
            merchant.ownerId, merchant.wxSource.subMerchantId, merchant.wxSource.subAliMerchantId
        ))
        return merchant

    wxApplier = merchant.wxSource

    # 首先尝试获取微信子商编号
    psiClient = get_psi_client()
    result = psiClient.query_sub_channel(merchant.agentNo, merchant.merchantNo)
    if "hlbWxSubNoResultInfo" not in result["data"]:
        logger.info("[update_channels_info] owner = <{}-{}>, not get subMchId and channelId".format(merchant.ownerRole, merchant.ownerId))
        merchant.to_fail(u"渠道编号获取错误")
        return merchant.reload()

    channelsInfo = json.loads(result["data"]["hlbWxSubNoResultInfo"])
    subMchId, channelId = channelsInfo["threePartnerNoData"][0]["threePartnerNo"], channelsInfo["threePartnerNoData"][0]["channelMerchantNo"]

    # 获取支付宝的子商户编号
    openClient = get_open_client()
    result = openClient.support.get_product_customer(merchant.merchantNo, "ALIPAY")
    subCustomerNum = merchant.wxSource.subAliMerchantId = result["data"][0]["subCustomerNum"]

    # 直接更新渠道编号
    wxApplier.update_sub_merchant(subMchId=subMchId, channel=channelId, subCustomerNum=subCustomerNum)
    return merchant.reload()


def is_wechat_authorized(merchant):
    """
    是否已经通过微信的审核
    """
    proxy = get_wechat_proxy()
    result = proxy.get_merchant_apply_state(merchant.wxSource.subMerchantId)
    return result["authorize_state"] == "AUTHORIZE_STATE_AUTHORIZED"


def is_alipay_authorized(merchant):
    """
    是否已经通过支付宝的审核 目前没有办法获取到支付宝的实名状态 一律返回True
    """
    return True


def query_audit_result(document, openClient):    # type: (Optional[None, JDOpenApplyInfo], JdOpenMerchantClient) -> Optional[None, JDOpenApplyInfo]
    """
    查询报单的结果
    """
    logger.info("[query_audit_result] duo_la_bao merchant <{}>".format(document))
    if not document:
        return

    data = {
        "agentNum": document.agentNum,
        "customerNum": document.customerNum
    }

    try:
        result = openClient.audit.get_audit_result(**data)
    except JdOpenException as je:
        logger.error("[query_audit_result] duo_la_bao merchant <{}> query audit result error = {} ".format(document, je))
        return

    logger.info("[query_audit_result] duo_la_bao merchant <{}>, result = {}".format(document, result))

    declareResult = result["data"]["declareList"][-1]

    # 根据京东审核的状态 确定不同的
    declareStatus = declareResult["declareStatus"]
    if declareStatus == JdOpenAuditStatus.PASS:
        logger.info("[query_audit_result] duo_la_bao merchant <{}>, audit pass".format(document))
        document.to_success()

    elif declareStatus == JdOpenAuditStatus.NOT_PASS:
        logger.info("[query_audit_result] duo_la_bao merchant <{}>, audit no pass".format(document))
        auditOpinion = declareResult["auditOpinion"]
        document.to_fail(auditOpinion)

    else:
        logger.info("[query_audit_result] duo_la_bao merchant <{}>, audit doing".format(document))

    return document


def get_wechat_auth_info(merchant):     # type:(Optional[JDOpenApplyInfo, MerchantSourceInfo]) -> dict
    """
    获取微信的实名信息
    """
    data = {
        "channel": "wechat",
        "status": AuthStatus.AUDIT,
        "subMerchantId": "",
        "description": ""
    }

    subMerchantId = merchant.wxSource.subMerchantId
    if not subMerchantId:
        return data

    data.update({"subMerchantId": subMerchantId})

    if is_wechat_authorized(merchant):
        data["status"] = AuthStatus.AUTHED
        return data

    applymentId = merchant.wxSource.applymentId
    if not applymentId:
        return data

    wechatProxy = get_wechat_proxy()
    result = wechatProxy.get_merchant_audit(merchant.wxSource.applymentId)

    if "applyment_state" not in result:
        return data

    elif result["applyment_state"] in [
        "APPLYMENT_STATE_PASSED",
        "APPLYMENT_STATE_WAITTING_FOR_CONFIRM_LEGALPERSON",
        "APPLYMENT_STATE_WAITTING_FOR_CONFIRM_CONTACT"
    ]:
        data["status"] = AuthStatus.PASS
        data["qrCode"] = "data:image/png;base64,{}".format(result["qrcode_data"])
        return data

    elif result["applyment_state"] in ["APPLYMENT_STATE_REJECTED"]:
        data["status"] = AuthStatus.NO_PASS
        data["description"] = u"【审核驳回】{}：{}，请联系平台客服处理".format(result["reject_param"], result["reject_reason"])
        return data

    else:
        return data


def get_alipay_auth_info(merchant):
    """
    获取支付宝的实名信息
    支付宝的时候一定要兼容之前的版本 之前从来没有获取过支付宝的子商户编号
    """
    data = {
        "channel": "ali",
        "status": AuthStatus.AUDIT,
        "subMerchantId": "",
        "description": ""
    }
    subMerchantId = merchant.wxSource.subAliMerchantId
    if not subMerchantId:
        merchant = update_channels_info(merchant)

    subMerchantId = merchant.wxSource.subAliMerchantId
    if subMerchantId:
        data["subMerchantId"] = subMerchantId
        data["status"] = AuthStatus.PASS
        data["qrCode"] = ALI_PAY_QR_CODE

    return data


class QueryMerchant(object):

    def __init__(self, merchant): # type:(MerchantSourceInfo) -> None
        self._mer = merchant

    def do(self):
        pass


class JdOpenParamsChecker(object):

    def __init__(self, **kwargs):
        self.data = {"id": kwargs.pop("id", "")}
        self.source = kwargs

    @staticmethod
    def area_check(area):
        return "code" in area and "name" in area

    @staticmethod
    def date_check(date):
        if date == "forever":
            return True
        try:
            datetime.datetime.strptime(date, "%Y-%m-%d")
        except ValueError:
            return False

        return True

    def create(self, owner):
        # 公共参数的检查
        self.common_check()

        # 公司商户的参数检查以及 商户创建
        if self.data["customerType"] == JdOpenMerchantType.COMPANY:
            self.check_company_merchant()
            return JDOpenApplyInfo.create_company(owner, **self.data)

        # 个人商户的参数检查 商户创建
        elif self.data["customerType"] == JdOpenMerchantType.PERSON:
            self.check_person_merchant()
            return JDOpenApplyInfo.create_personal(owner, **self.data)

        # 个体工商户的参数检查 商户创建
        elif self.data["customerType"] == JdOpenMerchantType.INDIVIDUALBISS:
            self.check_individualbiss_merchant()
            return JDOpenApplyInfo.create_individualbiss(owner, **self.data)

        # 事业单位的参数检查 商户创建
        else:
            self.check_institution_merchant()
            return JDOpenApplyInfo.create_institution(owner, **self.data)

    def common_check(self):
        """
        检测商户的基本信息 并将其赋值到data中
        """
        customerType = self.source.get("customerType")
        if customerType not in JdOpenMerchantType.choices():
            raise JdOpenParamsError(u"参数错误，商户类型错误")
        self.data["customerType"] = customerType

        shortName = self.source.get("shortName")
        if not shortName:
            raise JdOpenParamsError(u"参数错误，缺少商户简称")
        self.data["shortName"] = shortName

        province = self.source.get("province")
        city = self.source.get("city")
        district = self.source.get("district")
        address = self.source.get("address")

        if not all([province, city, district]):
            raise JdOpenParamsError(u"参数错误，缺少商户地区信息")
        if not self.area_check(province):
            raise JdOpenParamsError(u"参数错误，商户地区 省 信息错误")
        if not self.area_check(city):
            raise JdOpenParamsError(u"参数错误, 商户地区 市 信息错误")
        if not self.area_check(district):
            raise JdOpenParamsError(u"参数错误，商户地区 区 信息错误")
        if not address:
            raise JdOpenParamsError(u"参数错误，缺少商户详细地址")
        self.data["province"] = province
        self.data["city"] = city
        self.data["district"] = district
        self.data["address"] = address

        # 内部补充经纬度
        self.data["mapLng"], self.data["mapLat"] = get_location_by_area(province["name"], city["name"], district["name"], address)

    def check_person_merchant(self):
        """
        创建一条个人商户的记录
        """
        # 用户填写的个人界面的信息提取
        legalImgFront = self.source.get("legalImgFront")
        legalImgBack = self.source.get("legalImgBack")
        legalImgHold = self.source.get("legalImgHold")
        legalName = self.source.get("legalName")
        legalCardNo = self.source.get("legalCardNo")
        legalStart = self.source.get("legalStart")
        legalEnd = self.source.get("legalEnd")
        legalForever = self.source.get("legalForever")
        if not legalImgFront:
            raise JdOpenParamsError(u"参数错误，请上传收款人证件正面照")
        if not legalImgBack:
            raise JdOpenParamsError(u"参数错误，请上传收款人证件反面照")
        if not legalImgHold:
            raise JdOpenParamsError(u"参数错误，请上传收款人手持证件照")
        if not legalName:
            raise JdOpenParamsError(u"参数错误，缺少收款人姓名")
        if not legalCardNo:
            raise JdOpenParamsError(u"参数错误，缺少收款人证件号码")
        if not self.date_check(legalStart) or not self.date_check(legalEnd):
            raise JdOpenParamsError(u"参数错误, 收款人证件有效期错误")
        self.data["legalImgFront"] = legalImgFront
        self.data["legalImgBack"] = legalImgBack
        self.data["legalImgHold"] = legalImgHold
        self.data["legalName"] = legalName
        self.data["legalCardNo"] = legalCardNo
        self.data["legalStart"] = legalStart
        self.data["legalEnd"] = legalEnd if not legalForever else "forever"

        # 用户填写的结算界面的信息提取
        accountType = self.source.get("accountType")
        bankImg = self.source.get("bankImg")
        bankCardNo = self.source.get("bankCardNo")
        bankName = self.source.get("bankName")
        bankBranchName = self.source.get("bankBranchName")
        bankProvince = self.source.get("bankProvince")
        bankCity = self.source.get("bankCity")
        bankPhone = self.source.get("bankPhone")
        if not accountType:
            raise JdOpenParamsError(u"参数错误，请选择账户类型")
        if not bankImg:
            raise JdOpenParamsError(u"参数错误，请上传银行卡图片")
        if not bankCardNo:
            raise JdOpenParamsError(u"参数错误，缺少银行卡号")
        if not bankName:
            raise JdOpenParamsError(u"参数错误，缺少银行名称")
        if not bankBranchName:
            raise JdOpenParamsError(u"参数错误，缺少银行支行名称")
        if not all([bankProvince, bankCity]):
            raise JdOpenParamsError(u"参数错误，缺少银行地区信息")
        if not self.area_check(bankProvince) or not self.area_check(bankCity):
            raise JdOpenParamsError(u"参数错误，银行开户地区选择错误")
        if not bankPhone:
            raise JdOpenParamsError(u"参数错误，缺少银行卡预留手机号码")
        self.data["accountType"] = accountType
        self.data["bankImg"] = bankImg
        self.data["bankCardNo"] = bankCardNo
        self.data["bankName"] = bankName
        self.data["bankBranchName"] = bankBranchName
        self.data["bankProvince"] = bankProvince
        self.data["bankCity"] = bankCity
        self.data["bankPhone"] = bankPhone

        # 商店照片的信息的获取
        shopImgA = self.source.get("shopImgA")
        shopImgB = self.source.get("shopImgB")
        shopImgC = self.source.get("shopImgC")
        if not all([shopImgA, shopImgB, shopImgC]):
            raise JdOpenParamsError(u"参数错误，缺少营业照片")
        self.data["shopImgA"] = shopImgA
        self.data["shopImgB"] = shopImgB
        self.data["shopImgC"] = shopImgC

        # 联系人手机号码获取 这个字段的位置不固定 如果是个人 跟随法人信息确认 其余均在联系人地方
        phoneNumber = self.source.get("phoneNumber")
        if not phoneNumber:
            raise JdOpenParamsError(u"参数错误，缺少联系人手机号码")
        self.data["phoneNumber"] = phoneNumber

        # 非默认参数的补充
        self.data["fullName"] = u"个人_{}".format(self.data["legalName"])

    def check_individualbiss_merchant(self):
        """
        个体工商户 （简易版的企业商户 区别在于 个体工商户可以对私）
        """
        # 公司法人的参数校验
        legalImgFront = self.source.get("legalImgFront")
        legalImgBack = self.source.get("legalImgBack")
        legalName = self.source.get("legalName")
        legalCardNo = self.source.get("legalCardNo")
        legalStart = self.source.get("legalStart")
        legalEnd = self.source.get("legalEnd")
        legalForever = self.source.get("legalForever")
        if not legalImgFront:
            raise JdOpenParamsError(u"参数错误，请上传收款人证件正面照")
        if not legalImgBack:
            raise JdOpenParamsError(u"参数错误，请上传收款人证件反面照")
        if not legalName:
            raise JdOpenParamsError(u"参数错误，缺少收款人姓名")
        if not legalCardNo:
            raise JdOpenParamsError(u"参数错误，缺少收款人证件号码")
        if not self.date_check(legalStart) or not self.date_check(legalEnd):
            raise JdOpenParamsError(u"参数错误, 收款人证件有效期错误")
        self.data["legalImgFront"] = legalImgFront
        self.data["legalImgBack"] = legalImgBack
        self.data["legalName"] = legalName
        self.data["legalCardNo"] = legalCardNo
        self.data["legalStart"] = legalStart
        self.data["legalEnd"] = legalEnd if not legalForever else "forever"

        # 联系人信息的填写
        contactImgFront = self.source.get("contactImgFront")
        contactImgBack = self.source.get("contactImgBack")
        contactName = self.source.get("contactName")
        contactCardNo = self.source.get("contactCardNo")
        contactStart = self.source.get("contactStart")
        contactEnd = self.source.get("contactEnd")
        contactForever = self.source.get("contactForever")
        if not contactImgFront:
            raise JdOpenParamsError(u"参数错误，请上传联系人证件正面照")
        if not contactImgBack:
            raise JdOpenParamsError(u"参数错误，请上传联系人证件反面照")
        if not contactName:
            raise JdOpenParamsError(u"参数错误，缺少联系人姓名")
        if not contactCardNo:
            raise JdOpenParamsError(u"参数有误，缺少联系人证件号码")
        if not self.date_check(contactStart) or not self.date_check(contactEnd):
            raise JdOpenParamsError(u"参数错误, 联系人证件有效期错误")
        self.data["contactImgFront"] = contactImgFront
        self.data["contactImgBack"] = contactImgBack
        self.data["contactName"] = contactName
        self.data["contactCardNo"] = legalCardNo
        self.data["contactStart"] = contactCardNo
        self.data["contactEnd"] = contactEnd if not contactForever else "forever"

        # 营业执照的参数校验
        organizationImg = self.source.get("organizationImg")
        organizationName = self.source.get("organizationName")
        organizationNo = self.source.get("organizationNo")
        organizationStart = self.source.get("organizationStart")
        organizationEnd = self.source.get("organizationEnd")
        organizationProvince = self.source.get("organizationProvince")
        organizationCity = self.source.get("organizationCity")
        organizationDistrict = self.source.get("organizationDistrict")
        organizationAddress = self.source.get("organizationAddress")
        organizationForever = self.source.get("organizationForever")
        if not organizationImg:
            raise JdOpenParamsError(u"参数错误，请上传营业执照")
        if not organizationName:
            raise JdOpenParamsError(u"参数错误，缺少公司名称")
        if not organizationNo:
            raise JdOpenParamsError(u"参数错误，缺少统一信用码")
        if not self.date_check(organizationStart) or not self.date_check(organizationEnd):
            raise JdOpenParamsError(u"参数错误, 营业执照有效期填写错误")
        if not self.area_check(organizationProvince):
            raise JdOpenParamsError(u"参数错误，营业执照 省 信息错误")
        if not self.area_check(organizationCity):
            raise JdOpenParamsError(u"参数错误，营业执照 市 信息错误")
        if not self.area_check(organizationDistrict):
            raise JdOpenParamsError(u"参数错误，营业执照 区 信息错误")
        if not organizationAddress:
            raise JdOpenParamsError(u"参数错误，缺少营业执照详细地址")
        self.data["organizationImg"] = organizationImg
        self.data["organizationName"] = organizationName
        self.data["organizationNo"] = organizationNo
        self.data["organizationStart"] = organizationStart
        self.data["organizationEnd"] = organizationEnd if not organizationForever else "forever"
        self.data["organizationProvince"] = organizationProvince
        self.data["organizationCity"] = organizationCity
        self.data["organizationDistrict"] = organizationDistrict
        self.data["organizationAddress"] = organizationAddress

        # 用户填写的结算界面的信息提取
        accountType = self.source.get("accountType")
        bankImg = self.source.get("bankImg")
        bankCardNo = self.source.get("bankCardNo")
        bankName = self.source.get("bankName")
        bankBranchName = self.source.get("bankBranchName")
        bankProvince = self.source.get("bankProvince")
        bankCity = self.source.get("bankCity")
        bankPhone = self.source.get("bankPhone")
        if not accountType:
            raise JdOpenParamsError(u"参数错误，请选择账户类型")
        if not bankImg:
            raise JdOpenParamsError(u"参数错误，请上传开户许可证图片")
        if not bankCardNo:
            raise JdOpenParamsError(u"参数错误，缺少结算账号")
        if not bankName:
            raise JdOpenParamsError(u"参数错误，缺少结算银行名称")
        if not bankBranchName:
            raise JdOpenParamsError(u"参数错误，缺少结算银行支行名称")
        if not all([bankProvince, bankCity]):
            raise JdOpenParamsError(u"参数错误，缺少结算银行地区信息")
        if not self.area_check(bankProvince) or not self.area_check(bankCity):
            raise JdOpenParamsError(u"参数错误，结算银行开户地区选择错误")
        if not bankPhone:
            raise JdOpenParamsError(u"参数错误，缺少银行卡预留手机号码")
        self.data["accountType"] = accountType
        self.data["bankImg"] = bankImg
        self.data["bankCardNo"] = bankCardNo
        self.data["bankName"] = bankName
        self.data["bankBranchName"] = bankBranchName
        self.data["bankProvince"] = bankProvince
        self.data["bankCity"] = bankCity
        self.data["bankPhone"] = bankPhone

        # 商店照片的信息的获取
        shopImgA = self.source.get("shopImgA")
        shopImgB = self.source.get("shopImgB")
        shopImgC = self.source.get("shopImgC")
        if not all([shopImgA, shopImgB, shopImgC]):
            raise JdOpenParamsError(u"参数错误，缺少营业照片")

        self.data["shopImgA"] = shopImgA
        self.data["shopImgB"] = shopImgB
        self.data["shopImgC"] = shopImgC

        # 联系人手机号码获取 这个字段的位置不固定 如果是个人 跟随法人信息确认 其余均在联系人地方
        phoneNumber = self.source.get("phoneNumber")
        if not phoneNumber:
            raise JdOpenParamsError(u"参数错误，缺少联系人手机号码")

        self.data["phoneNumber"] = phoneNumber

        # 个体工商户的 商户全程为 营业执照名称
        self.data["fullName"] = u"{}".format(self.data["organizationName"])
        # 个体工商户的 组织机构代码 税务登记证 都是营业执照
        self.data["organizationcode"] = self.data["organizationImg"]
        self.data["taxregistration"] = self.data["organizationImg"]

        # 补充一下经办人的函件
        if contactName != legalName or contactCardNo != legalCardNo:
            businessAuthorizationLetter = self.source.get("businessAuthorizationLetter")
            if not businessAuthorizationLetter:
                raise JdOpenParamsError(u"参数错误，缺少业务办理授权函")
            else:
                self.data["businessAuthorizationLetter"] = businessAuthorizationLetter
        else:
            self.data["businessAuthorizationLetter"] = ""

    def check_company_merchant(self):
        """
        创建一条公司商户记录
        """
        # 公司法人的参数校验
        legalImgFront = self.source.get("legalImgFront")
        legalImgBack = self.source.get("legalImgBack")
        legalName = self.source.get("legalName")
        legalCardNo = self.source.get("legalCardNo")
        legalStart = self.source.get("legalStart")
        legalEnd = self.source.get("legalEnd")
        legalForever = self.source.get("legalForever")
        legalProvince = self.source.get("legalProvince")
        legalCity = self.source.get("legalCity")
        legalDistrict = self.source.get("legalDistrict")
        legalAddress = self.source.get("legalAddress")
        if not legalImgFront:
            raise JdOpenParamsError(u"参数错误，请上传法人证件正面照")
        if not legalImgBack:
            raise JdOpenParamsError(u"参数错误，请上传法人证件反面照")
        if not legalName:
            raise JdOpenParamsError(u"参数错误，缺少法人姓名")
        if not legalCardNo:
            raise JdOpenParamsError(u"参数错误，缺少法人证件号码")
        if not self.date_check(legalStart) or not self.date_check(legalEnd):
            raise JdOpenParamsError(u"参数错误, 法人证件有效期错误")
        if not all([legalProvince, legalCity, legalDistrict]):
            raise JdOpenParamsError(u"参数错误，缺少法人地区信息")
        if not self.area_check(legalProvince):
            raise JdOpenParamsError(u"参数错误，法人地区 省 信息错误")
        if not self.area_check(legalCity):
            raise JdOpenParamsError(u"参数错误, 法人地区 市 信息错误")
        if not self.area_check(legalDistrict):
            raise JdOpenParamsError(u"参数错误，法人地区 区 信息错误")
        if not legalAddress:
            raise JdOpenParamsError(u"参数错误，缺少商户详细地址")
        self.data["legalImgFront"] = legalImgFront
        self.data["legalImgBack"] = legalImgBack
        self.data["legalName"] = legalName
        self.data["legalCardNo"] = legalCardNo
        self.data["legalStart"] = legalStart
        self.data["legalEnd"] = legalEnd if not legalForever else "forever"
        self.data["legalProvince"] = legalProvince
        self.data["legalCity"] = legalCity
        self.data["legalDistrict"] = legalDistrict
        self.data["legalAddress"] = legalAddress

        # 联系人信息的填写
        contactImgFront = self.source.get("contactImgFront")
        contactImgBack = self.source.get("contactImgBack")
        contactName = self.source.get("contactName")
        contactCardNo = self.source.get("contactCardNo")
        contactStart = self.source.get("contactStart")
        contactEnd = self.source.get("contactEnd")
        contactForever = self.source.get("contactForever")
        if not contactImgFront:
            raise JdOpenParamsError(u"参数错误，请上传联系人证件正面照")
        if not contactImgBack:
            raise JdOpenParamsError(u"参数错误，请上传联系人证件反面照")
        if not contactName:
            raise JdOpenParamsError(u"参数错误，缺少联系人姓名")
        if not contactCardNo:
            raise JdOpenParamsError(u"参数有误，缺少联系人证件号码")
        if not self.date_check(contactStart) or not self.date_check(contactEnd):
            raise JdOpenParamsError(u"参数错误, 联系人证件有效期错误")
        self.data["contactImgFront"] = contactImgFront
        self.data["contactImgBack"] = contactImgBack
        self.data["contactName"] = contactName
        self.data["contactCardNo"] = legalCardNo
        self.data["contactStart"] = contactCardNo
        self.data["contactEnd"] = contactEnd if not contactForever else "forever"

        # 营业执照的参数校验
        organizationImg = self.source.get("organizationImg")
        organizationName = self.source.get("organizationName")
        organizationNo = self.source.get("organizationNo")
        organizationStart = self.source.get("organizationStart")
        organizationEnd = self.source.get("organizationEnd")
        organizationProvince = self.source.get("organizationProvince")
        organizationCity = self.source.get("organizationCity")
        organizationDistrict = self.source.get("organizationDistrict")
        organizationAddress = self.source.get("organizationAddress")
        organizationForever = self.source.get("organizationForever")
        if not organizationImg:
            raise JdOpenParamsError(u"参数错误，请上传营业执照")
        if not organizationName:
            raise JdOpenParamsError(u"参数错误，缺少公司名称")
        if not organizationNo:
            raise JdOpenParamsError(u"参数错误，缺少统一信用码")
        if not self.date_check(organizationStart) or not self.date_check(organizationEnd):
            raise JdOpenParamsError(u"参数错误, 营业执照有效期填写错误")
        if not self.area_check(organizationProvince):
            raise JdOpenParamsError(u"参数错误，营业执照 省 信息错误")
        if not self.area_check(organizationCity):
            raise JdOpenParamsError(u"参数错误，营业执照 市 信息错误")
        if not self.area_check(organizationDistrict):
            raise JdOpenParamsError(u"参数错误，营业执照 区 信息错误")
        if not organizationAddress:
            raise JdOpenParamsError(u"参数错误，缺少营业执照详细地址")
        self.data["organizationImg"] = organizationImg
        self.data["organizationName"] = organizationName
        self.data["organizationNo"] = organizationNo
        self.data["organizationStart"] = organizationStart
        self.data["organizationEnd"] = organizationEnd if not organizationForever else "forever"
        self.data["organizationProvince"] = organizationProvince
        self.data["organizationCity"] = organizationCity
        self.data["organizationDistrict"] = organizationDistrict
        self.data["organizationAddress"] = organizationAddress

        # 用户填写的结算界面的信息提取
        accountType = self.source.get("accountType")
        bankImg = self.source.get("bankImg")
        bankCardNo = self.source.get("bankCardNo")
        bankName = self.source.get("bankName")
        bankBranchName = self.source.get("bankBranchName")
        bankProvince = self.source.get("bankProvince")
        bankCity = self.source.get("bankCity")
        bankPhone = self.source.get("bankPhone")
        if not accountType:
            raise JdOpenParamsError(u"参数错误，请选择账户类型")
        if not bankImg:
            raise JdOpenParamsError(u"参数错误，请上传开户许可证图片")
        if not bankCardNo:
            raise JdOpenParamsError(u"参数错误，缺少结算账号")
        if not bankName:
            raise JdOpenParamsError(u"参数错误，缺少结算银行名称")
        if not bankBranchName:
            raise JdOpenParamsError(u"参数错误，缺少结算银行支行名称")
        if not all([bankProvince, bankCity]):
            raise JdOpenParamsError(u"参数错误，缺少结算银行地区信息")
        if not self.area_check(bankProvince) or not self.area_check(bankCity):
            raise JdOpenParamsError(u"参数错误，结算银行开户地区选择错误")
        if not bankPhone:
            raise JdOpenParamsError(u"参数错误，缺少银行卡预留手机号码")
        self.data["accountType"] = accountType
        self.data["bankImg"] = bankImg
        self.data["bankCardNo"] = bankCardNo
        self.data["bankName"] = bankName
        self.data["bankBranchName"] = bankBranchName
        self.data["bankProvince"] = bankProvince
        self.data["bankCity"] = bankCity
        self.data["bankPhone"] = bankPhone

        # 商店照片的信息的获取
        shopImgA = self.source.get("shopImgA")
        shopImgB = self.source.get("shopImgB")
        shopImgC = self.source.get("shopImgC")
        if not all([shopImgA, shopImgB, shopImgC]):
            raise JdOpenParamsError(u"参数错误，缺少营业照片")

        self.data["shopImgA"] = shopImgA
        self.data["shopImgB"] = shopImgB
        self.data["shopImgC"] = shopImgC

        # 联系人手机号码获取 这个字段的位置不固定 如果是个人 跟随法人信息确认 其余均在联系人地方
        phoneNumber = self.source.get("phoneNumber")
        if not phoneNumber:
            raise JdOpenParamsError(u"参数错误，缺少联系人手机号码")

        self.data["phoneNumber"] = phoneNumber

        # 企业商户的商户全称 为公司名称
        self.data["fullName"] = u"{}".format(self.data["organizationName"])
        # 企业商户的 组织机构代码 税务登记证 统一社会信用代码 都是营业执照
        self.data["organizationcode"] = self.data["organizationImg"]
        self.data["taxregistration"] = self.data["organizationImg"]
        self.data["unifiedsocialcreditcode"] = self.data["organizationImg"]

        # 补充一下经办人的函件
        if contactName != legalName or contactCardNo != legalCardNo:
            businessAuthorizationLetter = self.source.get("businessAuthorizationLetter")
            if not businessAuthorizationLetter:
                raise JdOpenParamsError(u"参数错误，缺少业务办理授权函")
            else:
                self.data["businessAuthorizationLetter"] = businessAuthorizationLetter
        else:
            self.data["businessAuthorizationLetter"] = ""

    def check_institution_merchant(self):
        """"""
        legalImgFront = self.source.get("legalImgFront")
        legalImgBack = self.source.get("legalImgBack")
        legalName = self.source.get("legalName")
        legalCardNo = self.source.get("legalCardNo")
        legalStart = self.source.get("legalStart")
        legalEnd = self.source.get("legalEnd")
        legalForever = self.source.get("legalForever")
        if not legalImgFront:
            raise JdOpenParamsError(u"参数错误，请上传法人证件正面照")
        if not legalImgBack:
            raise JdOpenParamsError(u"参数错误，请上传法人证件反面照")
        if not legalName:
            raise JdOpenParamsError(u"参数错误，缺少法人姓名")
        if not legalCardNo:
            raise JdOpenParamsError(u"参数错误，缺少法人证件号码")
        if not self.date_check(legalStart) or not self.date_check(legalEnd):
            raise JdOpenParamsError(u"参数错误, 法人证件有效期错误")
        self.data["legalImgFront"] = legalImgFront
        self.data["legalImgBack"] = legalImgBack
        self.data["legalName"] = legalName
        self.data["legalCardNo"] = legalCardNo
        self.data["legalStart"] = legalStart
        self.data["legalEnd"] = legalEnd if not legalForever else "forever"

        # 联系人信息的填写
        contactImgFront = self.source.get("contactImgFront")
        contactImgBack = self.source.get("contactImgBack")
        contactName = self.source.get("contactName")
        contactCardNo = self.source.get("contactCardNo")
        contactStart = self.source.get("contactStart")
        contactEnd = self.source.get("contactEnd")
        contactForever = self.source.get("contactForever")
        if not contactImgFront:
            raise JdOpenParamsError(u"参数错误，请上传联系人证件正面照")
        if not contactImgBack:
            raise JdOpenParamsError(u"参数错误，请上传联系人证件反面照")
        if not contactName:
            raise JdOpenParamsError(u"参数错误，缺少联系人姓名")
        if not contactCardNo:
            raise JdOpenParamsError(u"参数有误，缺少联系人证件号码")
        if not self.date_check(contactStart) or not self.date_check(contactEnd):
            raise JdOpenParamsError(u"参数错误, 联系人证件有效期错误")
        self.data["contactImgFront"] = contactImgFront
        self.data["contactImgBack"] = contactImgBack
        self.data["contactName"] = contactName
        self.data["contactCardNo"] = legalCardNo
        self.data["contactStart"] = contactCardNo
        self.data["contactEnd"] = contactEnd if not contactForever else "forever"

        # 营业执照的参数校验
        certType = self.source.get("certType")
        certImg = self.source.get("certImg")
        certName = self.source.get("certName")
        certNo = self.source.get("certNo")
        certStart = self.source.get("certStart")
        certEnd = self.source.get("certEnd")
        certProvince = self.source.get("certProvince")
        certCity = self.source.get("certCity")
        certDistrict = self.source.get("certDistrict")
        certAddress = self.source.get("certAddress")
        certForever = self.source.get("certForever")
        if not certType:
            raise JdOpenParamsError(u"参数错误")
        if not certImg:
            raise JdOpenParamsError(u"参数错误，请上传证书照片")
        if not certName:
            raise JdOpenParamsError(u"参数错误，缺少组织机构名称")
        if not certNo:
            raise JdOpenParamsError(u"参数错误，缺少组织机构码")
        if not self.date_check(certStart) or not self.date_check(certEnd):
            raise JdOpenParamsError(u"参数错误, 证书有效期填写错误")
        if not self.area_check(certProvince):
            raise JdOpenParamsError(u"参数错误，证书地区 省 信息错误")
        if not self.area_check(certCity):
            raise JdOpenParamsError(u"参数错误，证书地区 市 信息错误")
        if not self.area_check(certDistrict):
            raise JdOpenParamsError(u"参数错误，证书地区 区 信息错误")
        if not certAddress:
            raise JdOpenParamsError(u"参数错误，缺少证书详细地址")
        self.data["certType"] = certType
        self.data["certImg"] = certImg
        self.data["certName"] = certName
        self.data["certNo"] = certNo
        self.data["certStart"] = certStart
        self.data["certEnd"] = certEnd if not certForever else "forever"
        self.data["certProvince"] = certProvince
        self.data["certCity"] = certCity
        self.data["certDistrict"] = certDistrict
        self.data["certAddress"] = certAddress

        # 用户填写的结算界面的信息提取
        accountType = self.source.get("accountType")
        bankImg = self.source.get("bankImg")
        bankCardNo = self.source.get("bankCardNo")
        bankName = self.source.get("bankName")
        bankBranchName = self.source.get("bankBranchName")
        bankProvince = self.source.get("bankProvince")
        bankCity = self.source.get("bankCity")
        bankPhone = self.source.get("bankPhone")
        if not accountType:
            raise JdOpenParamsError(u"参数错误，请选择账户类型")
        if not bankImg:
            raise JdOpenParamsError(u"参数错误，请上传开户许可证图片")
        if not bankCardNo:
            raise JdOpenParamsError(u"参数错误，缺少结算账号")
        if not bankName:
            raise JdOpenParamsError(u"参数错误，缺少结算银行名称")
        if not bankBranchName:
            raise JdOpenParamsError(u"参数错误，缺少结算银行支行名称")
        if not all([bankProvince, bankCity]):
            raise JdOpenParamsError(u"参数错误，缺少结算银行地区信息")
        if not self.area_check(bankProvince) or not self.area_check(bankCity):
            raise JdOpenParamsError(u"参数错误，结算银行开户地区选择错误")
        if not bankPhone:
            raise JdOpenParamsError(u"参数错误，缺少银行卡预留手机号码")
        self.data["accountType"] = accountType
        self.data["bankImg"] = bankImg
        self.data["bankCardNo"] = bankCardNo
        self.data["bankName"] = bankName
        self.data["bankBranchName"] = bankBranchName
        self.data["bankProvince"] = bankProvince
        self.data["bankCity"] = bankCity
        self.data["bankPhone"] = bankPhone

        # 商店照片的信息的获取
        shopImgA = self.source.get("shopImgA")
        shopImgB = self.source.get("shopImgB")
        shopImgC = self.source.get("shopImgC")
        if not all([shopImgA, shopImgB, shopImgC]):
            raise JdOpenParamsError(u"参数错误，缺少营业照片")

        self.data["shopImgA"] = shopImgA
        self.data["shopImgB"] = shopImgB
        self.data["shopImgC"] = shopImgC

        # 联系人手机号码获取 这个字段的位置不固定 如果是个人 跟随法人信息确认 其余均在联系人地方
        phoneNumber = self.source.get("phoneNumber")
        if not phoneNumber:
            raise JdOpenParamsError(u"参数错误，缺少联系人手机号码")
        self.data["phoneNumber"] = phoneNumber

        # 资质信息检查
        certificateFile = self.source.get("certificateFile")
        specialQualification = self.source.get("specialQualification")
        if not certificateFile:
            raise JdOpenParamsError(u"参数错误，请上传单位证明函")
        if not specialQualification:
            raise JdOpenParamsError(u"参数错误，请上传特殊资质证书")
        self.data["certificateFile"] = certificateFile
        self.data["specialQualification"] = specialQualification

        # 非默认参数的补充
        self.data["fullName"] = u"{}".format(self.data["certName"])

        # 事业单位的 组织机构代码、税务登记证、统一社会信用代码 就是营业执照（证书）
        self.data["organizationcode"] = self.data["certImg"]
        self.data["taxregistration"] = self.data["certImg"]
        self.data["unifiedsocialcreditcode"] = self.data["certImg"]

        # 补充一下经办人的函件
        if contactName != legalName or contactCardNo != legalCardNo:
            businessAuthorizationLetter = self.source.get("businessAuthorizationLetter")
            if not businessAuthorizationLetter:
                raise JdOpenParamsError(u"参数错误，缺少业务办理授权函")
            else:
                self.data["businessAuthorizationLetter"] = businessAuthorizationLetter
        else:
            self.data["businessAuthorizationLetter"] = ""


class MerchantApplier(object):
    """
    商户申请
    负责维持状态到商户申请完成  包含递交商户资料 对商户申请状态轮询
    不负责实名 的任何任务 将实名与商户进行解耦
    各自商户申请完成各自实现函数
    """
    def __init__(self, merchant, client):   # type:(Optional[JDOpenApplyInfo, MerchantSourceInfo], Optional[JdPsiMerchantClient, JdOpenMerchantClient]) -> None
        self._merchant = merchant
        self._client = client

    def submit(self):
        pass

    def query_audit_result(self):
        pass


class JdPsiMerchantApplier(MerchantApplier):

    def submit(self):
        """
        创建商户
        """
        logger.info("[create_customer] psi merchant <{}>".format(self._merchant))

        if not self._merchant:
            return

        data = {"agentNo": self._merchant.agentNo}
        data.update(self._merchant.load_enter_image_info())
        data.update(self._merchant.load_enter_entity_info())

        try:
            result = self._client.create_customer(**data)
        except JdPsiException as je:
            self._merchant.to_fail(je.errMsg)
            return

        merchantNo = result.get("merchantNo")
        serialNo = result["data"]["serialNo"]

        self._merchant.enter_success(merchantNo, serialNo)

    def query_audit_result(self):
        """
        查询产品的开通状态 产品开通成功的情况下 进行秘钥查询
        """
        logger.info("[query_audit_result] query ownerId = {}".format(self._merchant.ownerId))
        if self._merchant.merchantStatus != int(MerchantStatus.WAITING):
            return

        # 将产品码和产品建立关系 方便后续处理
        productMap = {
            self._merchant.products[_name].productId: self._merchant.products[_name]
            for _name in self._merchant.products
        }

        # 发送查询的申请
        try:
            queryInfo = self._merchant.load_query_info()
            result = self._client.query_product(self._merchant.agentNo, **queryInfo)
        except JdPsiException as je:
            # 此处不需要切换失败的状态 等待下一次的轮询即可
            logger.error("query error!, record is <{}>, code = {}, error = {}".format(self._merchant.id, je.errCode, je.errMsg))
            return

        # 解析查询的结果
        products = result["dataList"]
        errorMsg = ""

        # 对每一个返回的产品信息进行轮询
        for _item in products:
            _productId = _item["productNo"]
            _product = productMap[_productId]

            status = _item.get("status")
            if int(status) == ProductStatus.FAIL:
                logger.error("product fail, record is <{}>, product is <{}>".format(self._merchant.id, _product.productId))
                errorMsg = _item.get("resultMsg", "")
                _product.to_fail()

            elif int(status) == ProductStatus.SUCCESS or int(status) == ProductStatus.CONFIRM:
                logger.info("product success, record is <{}>, product is <{}>".format(self._merchant.id, _product.productId))
                _product.to_success()

            else:
                logger.info("product waiting, record is <{}>, product is <{}>".format(self._merchant.id, _product.productId))

        # 商户重载一次 获取真实的产品开通状态
        merchant = self._merchant.reload()
        if merchant.is_product_fail():
            return merchant.to_fail(errorMsg)

        # 如果产品没有完全开通成功 直接退出 等待下一次的轮询
        if not merchant.is_product_success():
            return

        desKey, mdKey = self.query_secret()
        merchant.to_confirm(desKey=desKey, mdKey=mdKey)

    def query_secret(self):
        """
        查询秘钥
        """
        try:
            queryInfo = self._merchant.load_query_info()
            result = self._client.query_secret_key(self._merchant.agentNo, **queryInfo)
        except JdPsiException as je:
            logger.error("[query_secret] query secret error = {}, code = {}, record = {}".format(je.errMsg, je.errCode, self._merchant.id))
            return "", ""

        desKey, mdKey = result["data"]["desKey"], result["data"]["mdKey"]
        return desKey, mdKey

    def create_product(self):
        if not self._merchant.support_apply():
            logger.error("can not find merchant source info!")
            self._merchant.to_fail(u"不支持开通产品 请联系工作人员协查")
            return

        for _name in self._merchant.products:

            _product = self._merchant.products[_name]
            # 不符合开通产品条件的产品直接跳过
            if not _product.support_apply():
                continue

            # 先将产品的状态切换为等待状态
            _product.to_wait()

            _productInfo = self._merchant.load_product_info(_product)

            try:
                self._client.create_product(**_productInfo)
            except MerchantError as e:
                # 失败的情况下 切换产品状态为失败 切换商户状态为失败 用户重新提交资料 重新建立初始化状态的产品
                _product.to_fail()
                self._merchant.to_fail(e.message)


class JdOpenMerchantApplier(MerchantApplier):

    def submit(self):
        """
        新增商户 有可能是新增 或者是修改
        """
        logger.info("[create_customer] duo_la_bao merchant <{}>".format(self._merchant))

        if not self._merchant:
            return

        # 抽取公共信息
        data = {
            "agentNum": self._merchant.agentNum,
            "fullName": self._merchant.fullName,
            "shortName": self._merchant.shortName,
            "industry": self._merchant.industry,
            "province": self._merchant.province,
            "city": self._merchant.city,
            "district": self._merchant.district,

            "customerType": self._merchant.customerType,
            "certificateType": self._merchant.certificateType,
            "certificateCode": self._merchant.legalCardNo,
            "certificateName": self._merchant.legalName,
            "certificateStartDate": self._merchant.legalStart,
            "certificateEndDate": self._merchant.legalEnd if self._merchant.legalEnd != "forever" else "",
        }

        # 根据商户类型的不同 填充不同的信息
        if self._merchant.is_personal:
            data["linkMan"] = self._merchant.legalName
            data["linkPhone"] = self._merchant.phoneNumber
            data["contactPhoneNum"] = self._merchant.phoneNumber
            data["linkManId"] = self._merchant.legalCardNo

        elif self._merchant.is_company:
            data["linkMan"] = self._merchant.contactName
            data["linkPhone"] = self._merchant.phoneNumber
            data["contactPhoneNum"] = self._merchant.phoneNumber
            data["linkManId"] = self._merchant.contactCardNo

            data["postalAddress"] = self._merchant.organizationAddr

        elif self._merchant.is_institution:
            data["linkMan"] = self._merchant.contactName
            data["linkPhone"] = self._merchant.phoneNumber
            data["contactPhoneNum"] = self._merchant.phoneNumber
            data["linkManId"] = self._merchant.contactCardNo

            data["certType"] = self._merchant.certType
            data["certNum"] = self._merchant.certNo
            data["postalAddress"] = self._merchant.certAddr

        else:
            data["linkMan"] = self._merchant.contactName
            data["linkPhone"] = self._merchant.phoneNumber
            data["contactPhoneNum"] = self._merchant.phoneNumber
            data["linkManId"] = self._merchant.contactCardNo

            data["postalAddress"] = self._merchant.organizationAddr

        # 根据是否已经有商户编号 决定是新增还是修改
        try:
            if not self._merchant.customerNum:
                result = self._client.customer.create_customer(**data)
            else:
                result = self._client.customer.modify_customer(customerNum=self._merchant.customerNum, **data)
        except JdOpenException as je:
            logger.error("[create_customer] duo_la_bao merchant <{}> create customer error = {}".format(self._merchant, je))
            self._merchant.to_fail(je.message)
            return

        logger.info("[create_customer] duo_la_bao merchant <{}> create customer success，result = {}".format(self._merchant, result))
        customerNum = result["data"]["customerNum"]
        return self._merchant.to_customer(customerNum)

    def query_audit_result(self):
        pass

    def create_settle(self):
        """
        创建结算信息
        """
        logger.info("[create_settle] duo_la_bao merchant <{}>".format(self._merchant))

        if not self._merchant:
            return

        data = {
            "customerNum": self._merchant.customerNum,
            "bankAccountName": self._merchant.legalName,
            "bankAccountNum": self._merchant.bankCardNo,
            "province": self._merchant.bankProvince,
            "city": self._merchant.bankCity,
            "bankName": self._merchant.bankName,
            "bankBranchName": self._merchant.bankBranchName,
            "settleAmount": self._merchant.settleAmount,
            "payBankList": [pay.to_dict() for pay in self._merchant.payBankList],
            "accountType": self._merchant.accountType,
            "phone": self._merchant.bankPhone
        }
        if self._merchant.is_personal:
            data["accountType"] = self._merchant.accountType
            data["privateType"] = "PERSON"
            data["settlerCertificateCode"] = self._merchant.legalCardNo
            data["settlerCertificateStartDate"] = self._merchant.legalStart
            data["settlerCertificateEndDate"] = self._merchant.legalEnd if self._merchant.legalEnd != "forever" else ""

        elif self._merchant.is_company:
            data["accountType"] = self._merchant.accountType

        elif self._merchant.is_institution:
            data["accountType"] = self._merchant.accountType

        else:
            data["accountType"] = self._merchant.accountType
            if self._merchant.accountType == JdOpenAccountType.PRIVATE:
                data["privateType"] = "INDIVIDUAL"

                data["settlerCertificateCode"] = self._merchant.legalCardNo
                data["settlerCertificateStartDate"] = self._merchant.legalStart
                data["settlerCertificateEndDate"] = self._merchant.legalEnd if self._merchant.legalEnd != "forever" else ""

        try:
            if not self._merchant.settleNum:
                result = self._client.settle.create_account(**data)
            else:
                result = self._client.settle.modify_account(settleNum=self._merchant.settleNum, **data)
        except JdOpenException as je:
            logger.error("[create_settle] duo_la_bao merchant <{}> create settle error = {}".format(self._merchant, je))
            self._merchant.to_fail(je.message)
            return
        logger.info("[create_settle] duo_la_bao merchant <{}> create settle success, result = {}".format(self._merchant, result))

        settleNum = result["data"]["settleNum"]
        return self._merchant.to_settle(settleNum)

    def create_shop(self):
        logger.info("[create_shop] duo_la_bao merchant <{}>".format(self._merchant))

        if not self._merchant:
            return

        data = {
            "agentNum": self._merchant.agentNum,
            "customerNum": self._merchant.customerNum,
            "shopName": self._merchant.shortName,
            "address": self._merchant.merchantAddr,
            "oneIndustry": self._merchant.industry,
            "twoIndustry": self._merchant.subIndustry,
            "mobilePhone": self._merchant.phoneNumber,
            "mapLng": self._merchant.mapLng,
            "mapLat": self._merchant.mapLat
        }

        # 个人商户的类型暂时定死
        if self._merchant.is_personal:
            data["microBizType"] = "MICRO_TYPE_STORE"

        try:
            if not self._merchant.shopNum:
                result = self._client.shop.create_shop(**data)
            else:
                result = self._client.shop.modify_shop(shopNum=self._merchant.shopNum, **data)
        except JdOpenException as je:
            logger.error("[create_shop] duo_la_bao merchant <{}> create shop error = {}".format(self._merchant, je))
            self._merchant.to_fail(je.message)
            return

        logger.info("[create_shop] duo_la_bao merchant <{}> create shop success, result = {}".format(self._merchant, result))
        shopNum = result["data"]["shopNum"]
        return self._merchant.to_shop(shopNum)

    def upload_attaches(self):
        logger.info("[update_attach] duo_la_bao merchant <{}>".format(self._merchant))
        if not self._merchant:
            return

        # 组件公共组件
        attaches = {
            "CASHIERDESK": self._merchant.shopImgA,
            "SHOP": self._merchant.shopImgB,
            "IDENTITYDOOR": self._merchant.shopImgC,
            "IDENTITYFRONT": self._merchant.legalImgFront,
            "IDENTITYOPPOSITE": self._merchant.legalImgBack
        }

        if self._merchant.is_personal:
            attaches["IDENTIFYHANDHOLD"] = self._merchant.identifyhandhold
            attaches["BANKFRONT"] = self._merchant.bankImg

        elif self._merchant.is_company:
            attaches["PERMIT"] = self._merchant.bankImg

            attaches["LICENCE"] = self._merchant.organizationImg
            attaches["ORGANIZATIONCODE"] = self._merchant.organizationcode
            attaches["TAXREGISTRATION"] = self._merchant.taxregistration
            attaches["UNIFIEDSOCIALCREDITCODE"] = self._merchant.unifiedsocialcreditcode

        elif self._merchant.is_institution:
            attaches["PERMIT"] = self._merchant.bankImg

            attaches["LICENCE"] = self._merchant.certImg
            attaches["TAXREGISTRATION"] = self._merchant.taxregistration
            attaches["ORGANIZATIONCODE"] = self._merchant.organizationcode
            attaches["UNIFIEDSOCIALCREDITCODE"] = self._merchant.unifiedsocialcreditcode

            attaches["CERTIFICATE_FILE"] = self._merchant.certificateFile
            attaches["SPECIAL_QUALIFICATION"] = self._merchant.specialQualification

        else:
            if self._merchant.accountType == JdOpenAccountType.PUBLIC:
                attaches["PERMIT"] = self._merchant.bankImg
            else:
                attaches["BANKFRONT"] = self._merchant.bankImg
            attaches["LICENCE"] = self._merchant.organizationImg
            attaches["ORGANIZATIONCODE"] = self._merchant.organizationcode
            attaches["TAXREGISTRATION"] = self._merchant.taxregistration

        for attachType, img in attaches.items():  # type:(str, Attach)
            data = {
                "customerNum": self._merchant.customerNum,
                "attachType": attachType,
                "content": base64.b64encode(img.content)
            }
            try:

                if not img.attachNum:
                    result = self._client.attach.upload_attach(**data)
                else:
                    result = self._client.attach.modify_attach(attachNum=img.attachNum, **data)

                attachNum = result["data"]["attachNum"]
                img.upload_success(attachNum)

            except JdOpenException as je:
                logger.error("[update_attach] duo_la_bao merchant <{}> update attach <{}> error = {} ".format(self._merchant, attachType, je))
                self._merchant.to_fail(je.message)
                return
            logger.info("[update_attach] duo_la_bao merchant <{}> update attach <{}> success".format(self._merchant, attachType))

        else:
            return self._merchant.to_attach()

    def complete(self):
        logger.info("[complete_merchant] duo_la_bao merchant <{}>".format(self._merchant))

        if not self._merchant:
            return

        if self._merchant.is_personal:
            data = {
                "customerNum": self._merchant.customerNum
            }
        elif self._merchant.is_company:
            data = {
                "customerNum": self._merchant.customerNum,
                "licenseId": self._merchant.organizationNo,
                "licenseStartTime": self._merchant.organizationStart,
                "licenseEndTime": self._merchant.organizationEnd,
            }
        elif self._merchant.is_institution:
            data = {
                "customerNum": self._merchant.customerNum,
                "licenseId": self._merchant.certNo,
                "licenseStartTime": self._merchant.certStart,
                "licenseEndTime": self._merchant.certEnd,
            }
        else:
            data = {
                "customerNum": self._merchant.customerNum,
                "licenseId": self._merchant.organizationNo,
                "licenseStartTime": self._merchant.organizationStart,
                "licenseEndTime": self._merchant.organizationEnd,
            }

        try:
            result = self._client.complete.complete_customer(**data)
        except JdOpenException as je:
            logger.error("[complete_merchant] duo_la_bao merchant <{}> complete merchant result error = {} ".format(self._merchant, je))
            self._merchant.to_fail(je.message)
            return

        logger.info("[complete_merchant] duo_la_bao merchant <{}> complete merchant success ".format(self._merchant))
        return self._merchant.to_complete()

    def confirm(self):
        logger.info("[confirm_merchant] duo_la_bao merchant <{}>".format(self._merchant))
        if not self._merchant:
            return

        data = {
            "agentNum": self._merchant.agentNum,
            "customerNum": self._merchant.customerNum
        }

        try:
            result = self._client.complete.confirm_customer(**data)
        except JdOpenException as je:
            logger.error("[confirm_merchant] duo_la_bao merchant <{}> confirm merchant result error = {} ".format(self._merchant, je))
            self._merchant.to_fail(je.message)
            return

        logger.info("[confirm_merchant] duo_la_bao merchant <{}> confirm merchant success ".format(self._merchant))
        return self._merchant.to_confirm()


class MerchantApplyProxy(object):

    def __init__(self, merchant):       # type:(Optional[MerchantSourceInfo, JDOpenApplyInfo]) -> None
        self.merchant = merchant

    def submit_data(self):
        """
        将数据提供到商户方供给审核
        """
        merchant = self.merchant.reload()  # type: Optional[MerchantSourceInfo, JDOpenApplyInfo]

        if not merchant.support_enter():
            logger.error("[MerchantApplyProxy submit_data] not support enter merchant, merchantId = {}".format(self.merchant.id))
            return

        if isinstance(merchant, MerchantSourceInfo):
            applier = JdPsiMerchantApplier(merchant=merchant, client=get_psi_client())
        elif isinstance(merchant, JDOpenApplyInfo):
            applier = JdOpenMerchantApplier(merchant=merchant, client=get_open_client())
        else:
            logger.error("[MerchantApplyProxy submit_data] not support merchant type, merchantId = {}".format(self.merchant.id))
            return

        return applier.submit()

    def query_merchant_audit(self):
        """
        查询商户的审核状态
        """
        merchant = self.merchant.reload()  # type: Optional[MerchantSourceInfo, JDOpenApplyInfo]

        if not merchant.support_query_audit():
            logger.error("[MerchantApplyProxy query_merchant_audit] not support query audit, merchantId = {}".format(self.merchant.id))
            return

        if isinstance(merchant, MerchantSourceInfo):
            applier = JdPsiMerchantApplier(merchant=merchant, client=get_psi_client())
        elif isinstance(merchant, JDOpenApplyInfo):
            applier = JdOpenMerchantApplier(merchant=merchant, client=get_open_client())
        else:
            logger.error("[MerchantApplyProxy submit_data] not support merchant type, merchantId = {}".format(self.merchant.id))
            return

        # 查询商户的审核状态 如果审核成功 触发 下一步的行为 ()
        return applier.query_audit_result()

    def submit_auth(self):
        """
        提交 实名信息 分别向支付宝和微信提交
        """
        merchant = self.merchant.reload()  # type: Optional[MerchantSourceInfo, JDOpenApplyInfo]

        if not merchant.support_jdaggre():
            logger.error("[MerchantApplyProxy submit_auth] not support submit auth, merchantId = {}".format(self.merchant.id))
            return

        # 微信没有申请的
        if not merchant.is_wechat_submit:
            self.submit_wechat()

        # 支付宝没有提交申请资料的
        if not merchant.is_ali_submit:
            self.submit_ali()

        # 如果提交都成功了 切换状态
        merchant = self.merchant.reload()
        if all([merchant.is_wechat_submit, merchant.is_ali_submit]):
            merchant.to_auth_wait()

    def query_auth_audit(self):
        """
        查询实名审核的状态
        """
        wechatResult = self.query_wechat_audit()
        aliResult = self.query_ali_audit()

        if all([wechatResult, aliResult]):
            self.merchant.to_auth_apply_success()

    def submit_wechat(self):
        """
        提交微信审核资料
        """
        # 重载一次 防止状态变更失败
        merchant = self.merchant.reload()       # type: Optional[MerchantSourceInfo, JDOpenApplyInfo]

        if isinstance(merchant, MerchantSourceInfo):
            merchant = update_channels_info(merchant)
        elif isinstance(merchant, JDOpenApplyInfo):
            openClient = get_open_client()
            merchant = query_sub_merchantId(merchant, openClient)
        else:
            return

        wechatProxy = get_wechat_proxy()
        wxApplier = merchant.wxSource

        if not wxApplier.subMerchantId:
            logger.error("[submit_wechat] ownerId = {} no subMerchantId!".format(merchant.ownerId))
            return

        try:
            result = wechatProxy.submit_merchant(wxApplier)
        except MerchantError:
            logger.error("[submit_wechat] ownerId = {} submit error!".format(merchant.ownerId))
            return

        if "applyment_id" in result:
            applymentId = result["applyment_id"]
            merchant.to_wx_waiting(applymentId=applymentId)
        else:
            merchant.to_fail(result["message"])

    def query_wechat_audit(self):
        """
        查询微信 的审核
        """
        # 重载一次 防止状态变更失败
        merchant = self.merchant.reload()

        logger.info("[query_wechat_audit] ownerId = {}".format(merchant.ownerId))

        # 获取微信服务商
        wechatProxy = get_wechat_proxy()
        wxApplier = merchant.wxSource

        if not wxApplier.applymentId:
            logger.error("[query_wechat_audit] ownerId = {} not found applymentId".format(merchant.ownerId))
            return

        try:
            result = wechatProxy.get_merchant_audit(wxApplier.applymentId)
        except MerchantError:
            logger.error("[query_wechat_audit] ownerId = {} query error!".format(merchant.ownerId))
            return

        if "applyment_state" not in result:
            return False

        # 审核通过的
        if result["applyment_state"] in [
            "APPLYMENT_STATE_PASSED",
            "APPLYMENT_STATE_WAITTING_FOR_CONFIRM_LEGALPERSON",
            "APPLYMENT_STATE_WAITTING_FOR_CONFIRM_CONTACT"
        ]:
            return True

        # 审核驳回的
        if result["applyment_state"] in ["APPLYMENT_STATE_REJECTED"]:
            merchant.to_fail(u"【审核驳回】 {}：{}".format(result["reject_param"], result["reject_reason"]))
            return False

    def submit_ali(self):
        """
        提交支付宝的审核资料
        """
        pass

    def query_ali_audit(self):
        """
        阿里暂时全返回为True
        """
        return True