manyi/apps/web/merchant/views.py

# -*- coding: utf-8 -*-
import datetime
import logging

import simplejson as json
from django.http import HttpResponse
from django.views.generic import View
from typing import Optional

from apilib.bank_card_utils import BankRecognizer
from apilib.img_utils import ImageRecognizer, parse_identify_image, parse_bank_image, parse_business_image
from apilib.utils_sys import memcache_lock
from apps.web.agent.models import Agent
from apps.web.core import ROLE
from apps.web.core.exceptions import InvalidFileSize, InvalidFileName, MerchantError
from apps.web.core.file import AliOssFileUploader
from apps.web.core.messages.sms import jdMerchantSMSProvider
from apps.web.core.utils import JsonErrorResponse, JsonOkResponse
from apps.web.dealer.models import Dealer
from apps.web.merchant.exceptions import JdOpenParamsError
from apps.web.merchant.constant import MerchantStatus, WechatSubjectType, IdentificationType, CertType, MicroBizType, ContactType, ALI_PAY_QR_CODE
from apps.web.merchant.models import MerchantSourceInfo, MerchantAddress, JDOpenApplyInfo
from apps.web.merchant.utils import query_merchant_settle, get_wechat_proxy, JdOpenParamsChecker, get_open_client, query_audit_result, get_merchant_by_version, \
    is_wechat_authorized, is_alipay_authorized, get_wechat_auth_info, get_alipay_auth_info
from apps.web.merchant.validation import SettleValidator, BusinessValidator, CertificateValidator
from apps.web.utils import error_tolerate, permission_required
from apilib.exceptions import BaiDuApiImageError, BaiDuApiSysError, AliBankCardParamError, AliBankCardSysError
from library.jdpsi.exceptions import JdPsiException


logger = logging.getLogger(__name__)


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取失败"))
@permission_required(ROLE.dealer, ROLE.agent)
def getMerchantOptions(request):
    """
    获取商户的选项信息 在用户选择商户的时候进行加载
    """
    merchantOptions = WechatSubjectType.to_list()
    cardOptions = IdentificationType.to_list()
    certOptions = CertType.to_list()
    microOptions = MicroBizType.to_list()
    contactOptions = ContactType.to_list()

    return JsonOkResponse(payload={
        "merchantOptions": merchantOptions,
        "cardOptions": cardOptions,
        "certOptions": certOptions,
        "microOptions": microOptions,
        "contactOptions": contactOptions
    })


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取地址失败"))
@permission_required(ROLE.dealer, ROLE.agent)
def address(request):
    addresses = MerchantAddress.get_all()

    return JsonOkResponse(payload=addresses)


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"验证码获取失败"))
@permission_required(ROLE.dealer, ROLE.agent)
def sendMerchantSmsCode(request):
    if request.user.role == ROLE.dealer:
        dealerId = str(request.user.id)
        dealer = Dealer.objects.get(id=dealerId)
        agent = Agent.objects.get(id=dealer.agentId)
    else:
        agent = request.user

    payload = json.loads(request.body)
    mobile = payload["mobile"]

    # 防止接口被滥用 加上每日限制
    status, msg = jdMerchantSMSProvider.get(
        phoneNumber=mobile, productName=agent.productName,
        identify='{}_{}'.format(request.user.role, str(request.user.id)))

    if not status:
        return JsonErrorResponse(description=msg)

    return JsonOkResponse()


@error_tolerate(logger = logger, nil = JsonErrorResponse(u"请重试"))
@permission_required(ROLE.dealer, ROLE.agent)
def confirmMerchant(request, version):
    """
    确认商户的开通界面
    确认开通前 需要检查该商户是否状态一切就绪
    需要注意的是 返回正确的操作提示
    """
    owner = request.user

    # 获取微信的实名状态
    try:
        merchant = get_merchant_by_version(owner, version=version)   # type: MerchantSourceInfo
        wechatAuth = is_wechat_authorized(merchant)
        aliPayAuth = is_alipay_authorized(merchant)
    except MerchantError as me:
        return JsonErrorResponse(description=me.message)
    except Exception as e:
        logger.error("get wx merchant intention status error = {}".format(e))
        return JsonErrorResponse(u"获取实名状态失败，请刷新页面重试")

    # 两个实名确认状态是否满足
    if not wechatAuth:
        return JsonErrorResponse(u"微信实名尚未确认，请前往查看实名确认状态")
    if not aliPayAuth:
        return JsonErrorResponse(u"支付宝实名尚未确认，请前往查看实名确认状态")

    # 检查商户的角色是否已经 满足切换为京东支付
    try:
        owner.check_merchant_conditions()
    except MerchantError as me:
        return JsonErrorResponse(description=me.message)

    sourceRecord = MerchantSourceInfo.get_source_record(owner)
    sourceRecord.to_success()

    return JsonOkResponse()


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取信息失败，请重试"))
@permission_required(ROLE.dealer)
def getPartnerMerchantInfo(request):
    """
    获取 合伙人的 商户（银行卡）的绑定的状态
    :param request:
    :return:
    """
    return JsonErrorResponse(u"请登录合伙人账户进行商户开通")


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"保存信息失败"))
@permission_required(ROLE.dealer)
def savePartnerMerchantInfo(request):
    return JsonErrorResponse(u"请登录合伙人账户完成商户开通")


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"信息获取失败"))
@permission_required(ROLE.dealer, ROLE.agent)
def getAccount(request):
    user = request.user # type: Dealer

    try:
        merchant = MerchantSourceInfo.get_source_record(user)
        # 没有商户号 说明要么没有开通商户 要么商户是手动切换的 时间就换为大规模切换商户的开始时间
        if not merchant.status != MerchantStatus.SUCCESS:
            payload = {"merchantNo": "", "startTime": "2022-02-08"}
        else:
            payload = {"merchantNo": merchant.merchantNo, "startTime": merchant.dateTimeAdded.strftime("%Y-%m-%d")}
    except Exception:
        return JsonErrorResponse(u"查询商户失败")

    return JsonOkResponse(payload=payload)


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"信息获取失败"))
@permission_required(ROLE.dealer, ROLE.agent, ROLE.subaccount)
def getSettle(request):
    """
    获取商户的结算 转换为获取一段时间的
    """
    st = request.GET.get("startTime")
    et = request.GET.get("endTime")
    if not all([st, et]):
        return JsonErrorResponse(description=u"未查询到结算信息（10001）")

    # 转换日期格式区间
    try:
        st = datetime.datetime.strptime(st, "%Y-%m-%d")
        et = datetime.datetime.strptime(et, "%Y-%m-%d")
    except ValueError:
        return JsonErrorResponse(u"未查询到结算信息（10002）")

    if st > et:
        return JsonErrorResponse(u"未查询到结算信息（10003）")

    user = request.user
    try:
        result = query_merchant_settle(user, st, et)
    except JdPsiException as e:
        return JsonErrorResponse(description=u"查询失败，{}".format(e.errMsg))

    if not result:
        return JsonErrorResponse(u"未查询到结算信息（10004）")

    # 结构化数据
    settleMap = {_['settleDate']: _ for _ in result["dataList"]}

    dataList = list()
    for i in range((et-st).days + 1):
        _timeKey = (et-datetime.timedelta(days=i)).strftime("%Y-%m-%d")
        if _timeKey in settleMap:
            dataList.append(settleMap[_timeKey])
        else:
            dataList.append({
                u'orderStatus': u'UNKNOWN',
                u'remark': u'上日未产生收益',
                u'settleAccountNo': u'',
                u'settleDate': _timeKey,
                u'settlementAmount': u''
            })

    payload = {
        "dataList": dataList
    }
    return JsonOkResponse(payload=payload)


@error_tolerate(logger=logger, nil=JsonOkResponse())
@permission_required(ROLE.dealer)
def getAuths(request, version):
    """
    获取实名信息的列表
    """
    user = request.user
    mer = get_merchant_by_version(user, version)    # type: Optional[JDOpenApplyInfo, MerchantSourceInfo]
    # 目前来说只有微信和支付宝的实名确认

    # 微信
    wechat = get_wechat_auth_info(merchant=mer)

    # 支付宝
    alipay = get_alipay_auth_info(merchant=mer)

    return JsonOkResponse(payload={"dataList": [wechat, alipay]})


# ------------------------------- 新的接口 -----------------------------------------
@error_tolerate(logger=logger, nil=JsonErrorResponse(u"图片上传失败"))
@permission_required(ROLE.dealer)
def uploadImage(request):
    image = request.FILES.get("file")
    _type = request.GET.get("imageType")
    ocr = request.GET.get("ocr", False)
    cardSide = request.GET.get("cardSide")

    logger.info("[uploadImage] type = {}, ocr = {}, cardSide = {}, user = {}".format(_type, ocr, cardSide, request.user.id))

    # 防止文件类型上传错误
    fileSuffix = image.name.split(".")[1]
    if fileSuffix not in ["jpg", "jpeg", "png"]:
        return JsonErrorResponse(description = u"图片类型错误，请上传指的的图片类型（jpg，jpeg，png）。")

    # 根据类型以及其他参数 进行ocr识别 反馈有效的信息
    if int(ocr):
        try:
            recognizer = ImageRecognizer(request.user.id, inMemFile=image)
            if _type == "idCard":
                ocrData = recognizer.recognize_identify_card(cardSide, callback=parse_identify_image)
            elif _type == "bankCard":
                ocrData = recognizer.recognize_bank_card(callback=parse_bank_image)
            elif _type == "businessCard":
                ocrData = recognizer.recognize_business_license(callback=parse_business_image)
            else:
                ocrData = dict()
        except (BaiDuApiImageError, BaiDuApiSysError) as be:
            return JsonErrorResponse(description=be.message)
        except BaiDuApiSysError:
            return JsonErrorResponse(description=u"图像上传失败，请重试")
    else:
        logger.debug("[uploadImage] not need ocr!")
        ocrData = dict()

    # 上传保存图片
    uploader = AliOssFileUploader(inputFile=image, uploadType= 'merchant')
    try:
        outputUrl = uploader.upload()
    except InvalidFileSize as e:
        return JsonErrorResponse(description=e.message)
    except InvalidFileName as e:
        return JsonErrorResponse(description=e.message)

    payload = {
        "ocrData": ocrData,
        "url": outputUrl
    }
    return JsonOkResponse(payload=payload)


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"查找银行失败"))
@permission_required(ROLE.dealer)
def getBankName(request):
    card = request.GET.get("card")
    try:
        result = BankRecognizer(request.user.id).query_bank(card or "")
    except AliBankCardParamError as pe:
        return JsonErrorResponse(description=pe.message)
    except AliBankCardSysError as se:
        logger.error("[getBankName] error = {}".format(se))
        return JsonErrorResponse(u"查找银行失败")

    return JsonOkResponse(payload=result["data"][0])


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"查找银行失败"))
@permission_required(ROLE.dealer)
def getBankList(request):
    """
    查询支持的银行
    """
    search = request.GET.get("search")
    if not search:
        return JsonErrorResponse(description=u"请输入关键词查询")

    try:
        result = BankRecognizer(request.user.id).query_all_bank(search)
    except AliBankCardParamError as pe:
        return JsonErrorResponse(description=pe.message)
    except AliBankCardSysError as se:
        logger.error("[getBankList] error = {}".format(se))
        return JsonErrorResponse(u"查找银行失败")

    return JsonOkResponse(payload=result["data"])


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"查找支行失败"))
@permission_required(ROLE.dealer)
def getSubBankCodeList(request):
    """
    查询支行列表
    """
    pageIndex = int(request.GET.get("pageIndex", 1))
    queryKey = request.GET.get("queryKey", "")
    province = request.GET.get("bankProvince")
    city = request.GET.get("bankCity")
    bank = request.GET.get("bankName")
    card = request.GET.get("bankCardCode")

    if not all(["province", "city", "bank", "card"]):
        return JsonErrorResponse(description=u"参数错误")

    try:
        result = BankRecognizer(request.user.id).query_sub_code(
            bank=bank, card=card,
            province=province, city=city, queryKey=queryKey, page=pageIndex
        )
    except AliBankCardParamError as pe:
        return JsonOkResponse(description=pe.message)
    except AliBankCardSysError as se:
        logger.error("[getBankList] error = {}".format(se))
        return JsonErrorResponse(u"查找银行失败")

    return JsonOkResponse(payload=result["data"])


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"查找支行失败"))
@permission_required(ROLE.dealer)
def getSubBankCode(request, subCode):
    """
    通过联行号 反查银行的信息
    """
    try:
        result = BankRecognizer(request.user.id).query_sub_bank(subCode)
    except AliBankCardParamError as pe:
        return JsonErrorResponse(description=pe.message)
    except AliBankCardSysError as se:
        logger.error("[getBankList] error = {}".format(se))
        return JsonErrorResponse(u"查找银行失败")

    return JsonOkResponse(payload=result["data"][0])


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取商户信息失败"))
@permission_required(ROLE.dealer)
def getMerchantInfo(request, version):
    """
    获取商户的基本信息
    """
    user = request.user
    mer = get_merchant_by_version(user, version)

    merInfo = mer.get_merchant_info()
    helpInfo = mer.get_help_info()

    payload = {
        "merchantInfo": merInfo,
        "helpInfo": helpInfo
    }

    return JsonOkResponse(payload=payload)


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取二维码失败"))
@permission_required(ROLE.dealer)
def getAuthQrCode(request, version):
    """
    获取微信实名的二维码
    """
    user = request.user
    mer = get_merchant_by_version(user, version)

    wechatProxy = get_wechat_proxy()

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

    if "qrcode_data" not in result:
        return JsonOkResponse(u"获取实名二维码失败，请联系平台客服处理")

    return JsonOkResponse(payload={"qrCode": "data:image/png;base64,{}".format(result["qrcode_data"])})


class CertificateInfo(View):
    """
    """
    def __init__(self, **kwargs):
        super(CertificateInfo, self).__init__(**kwargs)
        self._owner = None
        self._merchant = None

    def dispatch(self, request, *args, **kwargs):
        self._owner = request.user
        self._merchant = MerchantSourceInfo.get_source_record(self._owner)  # type: MerchantSourceInfo

        return super(CertificateInfo, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        """
        获取商户的证件信息
        """
        data = self._merchant.get_certificate_info()
        data["merchantNo"] = self._merchant.merchantNo
        data["merchantType"] = self._merchant.wxSource.subjectInfo.mainType
        return JsonOkResponse(payload=data)

    def post(self, request):
        """
        存储商户的证件信息
        """
        data = json.loads(request.body)
        logger.info(
            "[CertificateInfo _ post] save merchant certificate info, user = {}, data = {}".format(self._owner.id, data)
        )
        validator = CertificateValidator(data)
        if not validator.is_valid():
            return JsonErrorResponse(description=json.dumps(validator.str_errors).decode("unicode-escape"))

        if not self._merchant.support_modify():
            return JsonErrorResponse(description=u"当前商户状态已锁定，无法进行修改")

        with memcache_lock(key="merchant_{}".format(self._owner.id), value="1", expire=10) as acquired:
            if not acquired:
                return JsonErrorResponse(description=u"当前商户正在修改中，请勿重复提交")

            self._merchant = self._merchant.save_certificate_info(validator.validated_data)

        data = self._merchant.get_certificate_info()
        data["merchantNo"] = self._merchant.merchantNo
        data["merchantType"] = self._merchant.wxSource.subjectInfo.mainType
        return JsonOkResponse(payload=data)


class SettlementInfo(View):
    def __init__(self, **kwargs):
        super(SettlementInfo, self).__init__(**kwargs)
        self._owner = None
        self._merchant = None

    def dispatch(self, request, *args, **kwargs):
        self._owner = request.user
        self._merchant = MerchantSourceInfo.get_source_record(self._owner)  # type: MerchantSourceInfo

        return super(SettlementInfo, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        data = self._merchant.get_settlement_info()
        data["merchantNo"] = self._merchant.merchantNo
        data["merchantType"] = self._merchant.wxSource.subjectInfo.mainType
        return JsonOkResponse(payload=data)

    def post(self, request):
        """
        存储商户的结算信息
        """
        data = json.loads(request.body)
        logger.info(
            "[SettlementInfo _ post] save merchant settle info, user = {}, data = {}".format(self._owner.id, data)
        )
        validator = SettleValidator(data)
        if not validator.is_valid():
            return JsonErrorResponse(description=json.dumps(validator.str_errors).decode("unicode-escape"))

        if not self._merchant.support_modify():
            return JsonErrorResponse(description=u"当前商户状态已锁定，无法进行修改结算信息")

        with memcache_lock(key="merchant_{}".format(self._owner.id), value="1", expire=10) as acquired:
            if not acquired:
                return JsonErrorResponse(description=u"当前商户正在修改中，请勿重复提交")

            self._merchant = self._merchant.save_settlement_info(validator.validated_data)

        data = self._merchant.get_settlement_info()
        data["merchantNo"] = self._merchant.merchantNo
        data["merchantType"] = self._merchant.wxSource.subjectInfo.mainType

        return JsonOkResponse(payload=data)


class BusinessInfo(View):

    def __init__(self, **kwargs):
        super(BusinessInfo, self).__init__(**kwargs)
        self._owner = None
        self._merchant = None

    def dispatch(self, request, *args, **kwargs):
        self._owner = request.user
        self._merchant = MerchantSourceInfo.get_source_record(self._owner)  # type: MerchantSourceInfo

        return super(BusinessInfo, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        data = self._merchant.get_business_info()
        data["merchantNo"] = self._merchant.merchantNo
        data["merchantType"] = self._merchant.wxSource.subjectInfo.mainType
        return JsonOkResponse(payload=data)

    def post(self, request):
        """
        存储商户的 营业信息
        """
        data = json.loads(request.body)
        logger.info(
            "[BusinessInfo _ post] save merchant settle info, user = {}, data = {}".format(self._owner.id, data)
        )
        businessInfo = data.get("businessInfo", dict())
        mobile = data.get("mobile", "")
        smsCode = data.get("SMSCode")
        result, msg = jdMerchantSMSProvider.verify(mobile, smsCode)
        if not result:
            return JsonErrorResponse(description=msg)

        validator = BusinessValidator(businessInfo)
        if not validator.is_valid():
            return JsonErrorResponse(description=json.dumps(validator.str_errors).decode("unicode-escape"))

        if not self._merchant.support_modify():
            return JsonErrorResponse(description=u"当前商户状态已锁定，无法进行修改")

        with memcache_lock(key=str(self._merchant.id), value="1") as acquired:
            if not acquired:
                return JsonErrorResponse(description=u"当前商户正在修改中，请勿重复提交")

            self._merchant = self._merchant.save_business_info(validator.validated_data)
            self._merchant = self._merchant.save_mobile_info(mobile)

        data = self._merchant.get_business_info()
        data["merchantNo"] = self._merchant.merchantNo
        data["merchantType"] = self._merchant.wxSource.subjectInfo.mainType

        self._merchant.to_waiting()

        return JsonOkResponse(payload=data)


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取行业列表失败"))
def getIndustry(request):
    num = request.GET.get("parent")
    openClient = get_open_client()
    if not num:
        result = openClient.support.query_industry()
    else:
        result = openClient.support.query_sub_industry(num)

    return JsonOkResponse(payload=result["data"])


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取地址信息失败"))
def getArea(request):
    province = request.GET.get("province")
    city = request.GET.get("city")

    openClient = get_open_client()
    if not province and not city:
        result = openClient.support.query_province()
    elif province:
        result = openClient.support.query_city(province)
    else:
        result = openClient.support.query_district(city)

    return JsonOkResponse(payload=result["data"])


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取支付产品失败"))
def getPayType(request):
    openClient = get_open_client()
    result = openClient.support.query_pay_type()
    return JsonOkResponse(payload=result["data"])


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取银行列表失败"))
def getBanks(request):
    keyWork = request.GET.get("keyWord")
    openClient = get_open_client()
    result = openClient.support.query_bank(keyWork)
    return JsonOkResponse(payload=result["data"])


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取支行列表"))
def getSubBanks(request):
    bankCode = request.GET.get("bankCode")
    keyWork = request.GET.get("keyWord")
    if not bankCode or not keyWork:
        return JsonOkResponse()

    openClient = get_open_client()
    result = openClient.support.query_sub_bank(bankCode, keyWork)
    return JsonOkResponse(payload=result["data"])


@error_tolerate(logger=logger, nil=HttpResponse(status=500))
def auditNotify(request):
    customerNum = request.GET.get("customerNum")
    auditStatus = request.GET.get("status")
    auditOpinion = request.GET.get("auditOpinion")

    return HttpResponse(status=200)


class JdOpenMerchant(View):
    """
    哆啦宝商户的获取和保存
    """
    def __init__(self, **kwargs):
        super(JdOpenMerchant, self).__init__(**kwargs)
        self._owner = None
        self._merchant = None

    def dispatch(self, request, *args, **kwargs):
        self._owner = request.user
        self._merchant = JDOpenApplyInfo.get_merchant_by_owner(self._owner)   # type: Optional[None, JDOpenApplyInfo]

        return super(JdOpenMerchant, self).dispatch(request, *args, **kwargs)

    def get(self, request):
        if self._merchant is None:
            mer = JDOpenApplyInfo()
        else:
            mer = self._merchant

        return JsonOkResponse(payload=mer.get_info())

    def post(self, request):
        """
        创建商户
        """
        payload = json.loads(request.body)
        logger.info("[{} post] user = {}, request body = {}, ".format(self.__class__.__name__, self._owner, payload))
        try:
            mer = JdOpenParamsChecker(**payload).create(self._owner)
        except JdOpenParamsError as jpe:
            return JsonErrorResponse(description=jpe.message)
        # 切换商户的资料到提交的状态
        mer = mer.to_submit()
        return JsonOkResponse()


@error_tolerate(logger=logger, nil=JsonErrorResponse(u"获取商户状态失败"))
def getMerchantAudit(request):
    """
    获取商户的审核状态
    """
    merchantId = request.GET.get("merchantId")
    if not merchantId:
        return JsonErrorResponse(description=u"商户编号错误，请刷新界面重试（10001）")

    mer = JDOpenApplyInfo.get_merchant_by_id(merchantId)
    if not mer:
        return JsonErrorResponse(description=u"商户编号错误，请刷新界面重试（10002）")

    openClient = get_open_client()
    result = query_audit_result(mer, openClient)

    return JsonOkResponse()