manyi/configs/base.py

# -*- coding: utf-8 -*-
# !/usr/bin/env python

import logging
import os
import sys

from configs import enum_define

reload(sys)
# noinspection PyUnresolvedReferences
sys.setdefaultencoding('utf-8')

from dotenv import load_dotenv, get_key
from os.path import abspath, join
from collections import namedtuple

CWD = abspath(os.path.split(os.path.realpath(__file__))[0])
PROJECT_ROOT = os.path.abspath(os.path.join(CWD, os.pardir))

sys.path.insert(0, PROJECT_ROOT)

# noinspection PyUnresolvedReferences
from version import VERSION

MY_ENV = os.environ.get('MY_ENV')

dotenv_path = abspath(join(PROJECT_ROOT, '.env.%s' % MY_ENV))

load_dotenv(dotenv_path)


def env(key, default = None):
    value = get_key(dotenv_path, key)
    if value is not None:
        return str(value)
    else:
        return str(os.environ.get(key, default))


MY_DOMAIN = os.environ.get('MY_DOMAIN')
FRONT_END_DOMAIN = os.environ.get('FRONT_END_DOMAIN')
COOKIE_DOMAIN = os.environ.get('FRONT_END_DOMAIN')

SECURITY_HTTP = True if os.environ.get('SECURITY_HTTP', 'yes') == 'yes' else False

# COOKIE_SECURE = SECURITY_HTTP

DEBUG = False
TEMPLATE_DEBUG = False
ALLOWED_HOSTS = ['*']

from mongoengine import register_connection

MongoCollection = namedtuple(
    'MongoCollection',
    ['alias', 'name', 'host', 'port', 'username', 'password', 'authentication_source']
)


def register_connections(*collections):
    # type:(MongoCollection) -> None
    for c in collections:
        register_connection(**c._asdict())

# noinspection PyUnresolvedReferences
MEDIA_ROOT = '/var/www/uploaded'
MEDIA_URL = '/uploaded/'

PRIVATE_MEDIA_ROOT = '/etc/washpayer_private_files'

STATIC_ROOT = os.path.join(PROJECT_ROOT, 'dist')
STATIC_URL = '/'

WECHAT_SUBSCRIPTION_ACCOUNT_VERIFY_PATH = STATIC_ROOT

MIDDLEWARE_CLASSES = (
    'django.middleware.common.CommonMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    # 'django.middleware.gzip.GZipMiddleware',
    # 'mongo_auth.middleware.LazyUserMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'middlewares.django_jwt_session_auth.JwtAuthMiddleware',
    'middlewares.validPermission.PermissionMiddleware'
    # 'crashlog.CrashLogMiddleware',
)

ROOT_URLCONF = 'urls'

INSTALLED_APPS = (
    'django.contrib.sessions',
    'library.mongo_django_auth_backport',
    'apps.patch',
    'apps.web',
)

# registration setting
SESSION_EXPIRE_AT_BROWSER_CLOSE = True  # TODO:在firefox中无效  #request.session.set_expiry(0)#TODO:对firefox也无效

AUTH_USER_MODEL = 'apps.web.core.db.UserSearchable'
SESSION_ENGINE = 'library.mongo_django_auth_backport.sessions'

AUTHENTICATION_BACKENDS = (
    'apps.web.utils.AgentAuthBackend',
    'apps.web.utils.DealerAuthBackend',
    'apps.web.utils.ManagerAuthBackend',
    'apps.web.utils.SuperManagerAuthBackend',
    'apps.web.utils.AdvertisementAuthBackend',
    'apps.web.utils.AdvertiserAuthBackend',
    'apps.web.utils.SubAccountBackend',
    'apps.web.user.models.MyUserAuthBackend'
)

LOGGING_OUTPUT_ENABLED = True
LOGGING_SHOW_METRICS = False
LOGGING_LOG_SQL = False

# if Django is running behind a proxy, we need to do things like use
# HTTP_X_FORWARDED_FOR instead of REMOTE_ADDR. This setting is used
# to inform apps of this fact
BEHIND_PROXY = True  # TODO:TO CONFIRM!

# 这一系列的配置用于Web Server的API接口
JAPI_SECRET = env('JAPI_SECRET')
JAPI_RETRY_COUNT = 0
JAPI_RETRY_DELAY = 10

# 邮件的主题前缀
EMAIL_SUBJECT_PREFIX = '[Washpayer] '

# 邮件服务器
EMAIL_HOST = 'smtp.163.com'

# 发送端口 163的端口 当使用tls的时候 端口为465 当使用ssl 的时候端口为465 配对出现 不能乱
EMAIL_PORT = 465
EMAIL_USE_SSL = True

# 发送邮箱
SERVER_EMAIL = '17625905485@163.com'

# 邮件发送人 当使用163邮箱的时候 与server_email 相同 两者的区别 一个是用来登录smtp邮箱服务器的 一个是显示邮箱发送人的
EMAIL_HOST_USER = SERVER_EMAIL
EMAIL_HOST_PASSWORD = 'XLGOZFPKYDABTLED'

# 收件人以及邮箱信息
ADMINS = (("zjl", "17625905485@163.com"), ("sp", "32899523@qq.com"),)

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,

    'formatters': {
        'simple': {
            'format': '[%(asctime)s] %(levelname)s : %(message)s',
            'datefmt': '%Y-%m-%d %H:%M:%S'
        },
        'verbose': {
            'format': '[%(asctime)s] %(levelname)s[%(thread)d] [%(name)s:%(lineno)d]: %(message)s',
            'datefmt': '%Y-%m-%d %H:%M:%S'
        },
        'standard': {
            'format': '%(asctime)s %(levelname)s[%(threadName)s:%(thread)d] [%(name)s:%(lineno)d] [%(levelname)s]- %(message)s',
            'datefmt': '%Y-%m-%d %H:%M:%S'
        },
    },

    'handlers': {
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',
            'stream': sys.stdout,
            'formatter': 'verbose',
        },

        'fileHandler': {
            'level': 'DEBUG',
            'class': 'logging.handlers.WatchedFileHandler', # 使用系统logrotate轮转日志
            'filename': os.environ.get('LOG_PATH', 'logs'),
            'formatter': 'verbose'
        }
    },

    'loggers': {
        'django': {
            # 'handlers': ['console'],
            'handlers': ['console'] if not os.environ.get('LOG_PATH', None) else ['fileHandler'],
            'level': 'DEBUG',
            'propagate': True,
        },
        '': {
            # 'handlers': ['console'],
            'handlers': ['console'] if not os.environ.get('LOG_PATH', None) else ['fileHandler'],
            'level': 'DEBUG',
            'propagate': True
        },

        'requests.packages.urllib3': {
            # 'handlers': ['console'],
            'handlers': ['console'] if not os.environ.get('LOG_PATH', None) else ['fileHandler'],
            'level': logging.WARNING
        },

        'matplotlib': {
            # 'handlers': ['console'],
            'handlers': ['console'] if not os.environ.get('LOG_PATH', None) else ['fileHandler'],
            'level': logging.WARNING
        },

        'amqp': {
            # 'handlers': ['console'],
            'handlers': ['console'] if not os.environ.get('LOG_PATH', None) else ['fileHandler'],
            'level': logging.WARNING
        },

        'urllib3': {
            # 'handlers': ['console'],
            'handlers': ['console'] if not os.environ.get('LOG_PATH', None) else ['fileHandler'],
            'level': logging.WARNING
        }
    },
}

# List of callables that know how to import templates from various sources.
TEMPLATE_LOADERS = (
    # 'django.template.loaders.app_directories.Loader',
    'django.template.loaders.filesystem.Loader',
)

TEMPLATE_DIRS = (
    os.path.join(PROJECT_ROOT, "templates"),
)

TEMPLATE_CONTEXT_PROCESSORS = (
    'django.contrib.auth.context_processors.auth',
    'django.core.context_processors.debug',
    'django.core.context_processors.media',
    'django.core.context_processors.static',
    'django.core.context_processors.tz',
    'django.contrib.messages.context_processors.messages',
)

STATIC_SERVER_URL = 'http://127.0.0.1:80'


def my_key_fun(key, key_prefix, version):
    return "manyi_{}".format(key)


CACHES = {

    'default': {
        'BACKEND': 'library.djmemcache.backend.PyMemcacheCache',
        'LOCATION': env('MEMCACHE_DEFAULT').split(','),
        "TIMEOUT": 7 * 24 * 3600,
        'KEY_FUNCTION': my_key_fun,
        'OPTIONS': {
            'POOL_IDLE_TIMEOUT': 60,
            'MAX_POOL_SIZE': 65000,
            'TIMEOUT': 5,
            'CONNECT_TIMEOUT': 3,
            # 'IGNORE_EXC': True,
            'USE_POOLING': True
        }
    },

    'report': {
        'BACKEND': 'library.djmemcache.backend.PyMemcacheCache',
        'LOCATION': env('MEMCACHE_REPORT').split(','),
        "TIMEOUT": 72 * 3600,
        'KEY_FUNCTION': my_key_fun,
        'OPTIONS': {
            'POOL_IDLE_TIMEOUT': 60,
            'MAX_POOL_SIZE': 65000,
            'TIMEOUT': 5,
            'CONNECT_TIMEOUT': 3,
            # 'IGNORE_EXC': True,
            'USE_POOLING': True
        }
    },

    # 'devmgr': {
    #     'BACKEND': 'library.memcache_backend.CustomizedMemcachedCacheBackend',
    #     'LOCATION': env('MEMCACHE_DEVMGR').split(','),
    #     "TIMEOUT": 48 * 3600,
    #     "KEY_FUNCTION": my_key_fun
    # },

    'devmgr': {
        'BACKEND': 'library.djmemcache.backend.PyMemcacheCache',
        'LOCATION': env('MEMCACHE_DEVMGR').split(','),
        "TIMEOUT": 2 * 24 * 3600,
        'KEY_FUNCTION': my_key_fun,
        'OPTIONS': {
            'POOL_IDLE_TIMEOUT': 60,
            'MAX_POOL_SIZE': 65000,
            'TIMEOUT': 5,
            'CONNECT_TIMEOUT': 3,
            # 'IGNORE_EXC': True,
            'USE_POOLING': True
        }
    },

    'service': {
        'BACKEND': 'library.djmemcache.backend.PyMemcacheCache',
        'LOCATION': env('MEMCACHE_SERVICE').split(','),
        "TIMEOUT": 7 * 24 * 3600,
        'KEY_FUNCTION': my_key_fun,
        'OPTIONS': {
            'POOL_IDLE_TIMEOUT': 60,
            'MAX_POOL_SIZE': 65000,
            'TIMEOUT': 5,
            'CONNECT_TIMEOUT': 3,
            # 'IGNORE_EXC': True,
            'USE_POOLING': True
        }
    },

    'lock': {
        'BACKEND': 'library.djmemcache.backend.PyMemcacheCache',
        'BACKEND_TYPE': 'pool',
        'LOCATION': env('MEMCACHE_LOCK').split(','),
        "TIMEOUT": 24 * 3600 * 7,
        'KEY_FUNCTION': my_key_fun,
        'OPTIONS': {
            'POOL_IDLE_TIMEOUT': 60,
            'MAX_POOL_SIZE': 65000,
            'TIMEOUT': 5,
            'CONNECT_TIMEOUT': 3,
            # 'IGNORE_EXC': True,
            'USE_POOLING': True
        }
    }
}

TIME_ZONE = 'Asia/Shanghai'

TEST_RUNNER = 'testcase.MongoBasedTestRunner'

if SECURITY_HTTP:
    SERVER_END_BASE_URL = 'https://{}'.format(MY_DOMAIN)
else:
    SERVER_END_BASE_URL = 'http://{}'.format(MY_DOMAIN)

SERVER_END_BASE_SSL_URL = 'https://{}'.format(MY_DOMAIN)

if SECURITY_HTTP:
    FRONT_END_BASE_URL = 'https://{}'.format(FRONT_END_DOMAIN)
else:
    FRONT_END_BASE_URL = 'http://{}'.format(FRONT_END_DOMAIN)

SECRET_KEY = 'bk-e2zv3humar79nm=j*bwc=-ymeit132481113goq4dh732%s'

# 配置是否记录OPENID
OPEN_ID_NEEDED = True

# 万能密码
UNIVERSAL_PASSWORD = env('UNIVERSAL_PASSWORD')

# 提现所需最小值
WITHDRAW_MINIMUM = 10
AD_WITHDRAW_MINIMUM = 1
SIM_INCOME_WITHDRAW_MINIMUM = 10

# 提现所需最大值
WITHDRAW_MAXIMUM = 20000

DEFAULT_AVATAR_URL = ""

# 网络通信超时时间，默认为60秒
MESSAGE_SENDER_TIMEOUT = 60

CAN_WITHDRAW_FUND = True

WHALE_WITHDRAWAL_ORDER_AMOUNT = 15000

FINANCE_MANAGER_TEL = '13797019121'

DEFAULT_CUSTOMER_SERVICE_TEL = ''

REDIS_HOST = env('REDIS_HOST')
REDIS_PORT = int(env('REDIS_PORT'))
REDIS_DB = env('REDIS_DB')

CELERY_RESULT_URL_PREFIX = env('CELERY_RESULT_URL_PREFIX')

LOGO_ROOT = os.path.join(MEDIA_ROOT, 'logo')
LOGO_URL = '%slogo/' % MEDIA_URL

QRCODE_ROOT = os.path.join(MEDIA_ROOT, 'qrcode')
QRCODE_URL = '%sqrcode/' % MEDIA_URL

CREATIVE_ROOT = os.path.join(MEDIA_ROOT, 'creative')
CREATIVE_URL = '%screative/' % MEDIA_URL

USER_IDENT_ROOT = os.path.join(MEDIA_ROOT, 'identify')
USER_IDENT_URL = '%sidentify/' % MEDIA_URL

ITEM_ROOT = os.path.join(MEDIA_ROOT, 'item')
ITEM_URL = '%sitem/' % MEDIA_URL

FAULT_ROOT = os.path.join(MEDIA_ROOT, 'fault')
FAULT_URL = '%sfault/' % MEDIA_URL
# MQTT
MQTT_HOSTNAME = env('MQTT_HOSTNAME')
MQTT_PORT = int(env('MQTT_PORT'))
MQTT_PORT_SECURITY = int(env('MQTT_PORT_SECURITY'))
MQTT_USER = env('MQTT_USER')
MQTT_PSWD = env('MQTT_PSWD')

defaultCollection = MongoCollection('default', str(env('MONGODB_WASHPAY_NAME')), str(env('MONGODB_IP')),
                                    int(env('MONGODB_PORT')) if env('MONGODB_PORT') is not "" else None,
                                    env('MONGODB_WASHPAY_USER'),
                                    env('MONGODB_WASHPAY_PASSWORD'), env('MONGODB_WASHPAY_AUTH_DB'))
reportCollection = MongoCollection('report', str(env('MONGODB_REPORT_NAME')), str(env('MONGODB_IP')),
                                   int(env('MONGODB_PORT')) if env('MONGODB_PORT') is not "" else None,
                                   env('MONGODB_REPORT_USER'),
                                   env('MONGODB_REPORT_PASSWORD'), env('MONGODB_REPORT_AUTH_DB'))
logdataCollection = MongoCollection('logdata', str(env('MONGODB_LOGDATA_NAME')), str(env('MONGODB_IP')),
                                    int(env('MONGODB_PORT')) if env('MONGODB_PORT') is not "" else None,
                                    env('MONGODB_LOGDATA_USER'),
                                    env('MONGODB_LOGDATA_PASSWORD'), env('MONGODB_LOGDATA_AUTH_DB'))

register_connections(defaultCollection, reportCollection, logdataCollection)

CELERY_BROKER_URL = env('CELERY_BROKER_URL')
CELERY_RESULT_BACKEND = env('CELERY_RESULT_BACKEND')

MAX_DISTANCE_TO_SHOW_AD = 1  # km

AD_LOCATION_LIMIT = True

# 是否跳过验证码校验
SKIP_VERIFY_SMS = False

SEND_SMS_IS_ALLOWED = True

CHECK_DEVICE_SMS_EXPIRE = False

SEND_DEALER_WECHAT_PUSH_MESSAGE = False

TELL_MANAGER = True

WECHAT_PUSH_ENABLED = True

SERVICE_DOMAIN = enum_define(USER = 'MyUser',
                             DEALER = 'Dealer',
                             SUBACCOUNT = 'SubAccount',
                             AGENT = 'Agent',
                             MANAGER = 'Manager',
                             ADVERTISEMENT = 'Advertisement',
                             ADVERTISER = 'Advertiser',
                             SUPERMANAGER = 'SuperManager',
                             TESTER = 'Tester')

JWT_AUTH_DOMAIN_COOKIE_NAME = 'jwt_auth_domain'
JWT_AUTH_DOMAIN_HEADER_NAME = 'jwt-auth-domain'
JWT_TOKEN_HEADER_NAME = 'jwt-token'

JWT_AUTH_DOMAIN_DJANGO = 'HTTP_JWT_AUTH_DOMAIN'
JWT_TOKEN_DJANGO = 'HTTP_JWT_TOKEN'

JWT_SERVICE_DOMAIN_MAP = {
    '/userLogin': {
        'authDomain': SERVICE_DOMAIN.USER,
        'pre': True,
        'post': False
    },

    '/user/wechat/auth/base': {
        'authDomain': SERVICE_DOMAIN.USER,
        'pre': False,
        'post': False
    },

    '/user/wechat/managerAuth/base': {
        'authDomain': SERVICE_DOMAIN.USER,
        'pre': False,
        'post': False
    },

    '/user/wechat/managerAuth/user': {
        'authDomain': SERVICE_DOMAIN.USER,
        'pre': False,
        'post': False
    },

    '/user/wechat/center/auth/base': {
        'authDomain': SERVICE_DOMAIN.USER,
        'pre': False,
        'post': False
    },

    '/user/wechat/center/auth/user': {
        'authDomain': SERVICE_DOMAIN.USER,
        'pre': False,
        'post': False
    },

    '/user/wechat/center/managerAuth/user': {
        'authDomain': SERVICE_DOMAIN.USER,
        'pre': False,
        'post': False
    },

    '/user/wxpay/baseAccess': {
        'authDomain': SERVICE_DOMAIN.USER,
        'pre': False,
        'post': False
    },

    '/dealerAccess': {
        'authDomain': SERVICE_DOMAIN.DEALER,
        'pre': False,
        'post': True
    },

    '/dealer/login': {
        'authDomain': SERVICE_DOMAIN.DEALER,
        'pre': False,
        'post': True
    },

    '/subAccount/login': {
        'authDomain': SERVICE_DOMAIN.SUBACCOUNT,
        'pre': False,
        'post': True
    },

    '/agent/login': {
        'authDomain': SERVICE_DOMAIN.AGENT,
        'pre': False,
        'post': True
    },

    '/superadmin/login': {
        'authDomain': SERVICE_DOMAIN.SUPERMANAGER,
        'pre': False,
        'post': True
    },

    '/manager/login': {
        'authDomain': SERVICE_DOMAIN.MANAGER,
        'pre': False,
        'post': True
    },

    '/ad/advertiserLogin': {
        'authDomain': SERVICE_DOMAIN.ADVERTISER,
        'pre': False,
        'post': True
    }
}

JWT_AUTH = {
    SERVICE_DOMAIN.USER: {
        'PAYLOAD_TO_USER': 'apps.web.user.auth.payload_to_user',
        'USER_TO_PAYLOAD': 'apps.web.user.auth.user_to_payload',
        'USER_KEY': 'id',
        'SECRET': env('JWT_SECRET') or '98d0457b02917c39b66bbb92b089bf9b',
        'SESSION': {
            'EXPIRE': 3600 * 24 * 30,
            'PREFIX': 'JWT_AUTH_CACHE:%s:' % SERVICE_DOMAIN.USER
        }
    },
    SERVICE_DOMAIN.TESTER: {
        'PAYLOAD_TO_USER': 'apps.web.test.auth.payload_to_user',
        'USER_TO_PAYLOAD': 'apps.web.test.auth.user_to_payload',
        'USER_KEY': 'id',
        'SECRET': env('JWT_SECRET') or 'MNa6mGYaRk2kGqVf0Kouz3Uc8PgBdR1U',
        'SESSION': {
            'EXPIRE': 3600 * 24 * 30,
            'PREFIX': 'JWT_AUTH_CACHE:%s:' % SERVICE_DOMAIN.USER
        }
    },
    # SERVICE_DOMAIN.DEALER: {
    #     'PAYLOAD_TO_USER': 'apps.web.dealer.auth.payload_to_user',
    #     'USER_TO_PAYLOAD': 'apps.web.dealer.auth.user_to_payload',
    #     'USER_KEY': 'id',
    #     'SECRET': env('JWT_SECRET') or '98d0457b02917c39b66bbb92b089bf9b',
    #     'SESSION': {
    #         'EXPIRE': 3600 * 24 * 30,
    #         'PREFIX': 'JWT_AUTH_CACHE:%s:' % SERVICE_DOMAIN.DEALER
    #     }
    # }
}

DEBUG_JWT = False

DEBUG_CELERY_TASK_ROUTINE = False
DEBUG_CELERY_TASK = False
NO_CELERY_TASK = False

DEFAULT_DEALER_PUSH_BROKER_URL = env('DEFAULT_DEALER_PUSH_BROKER_URL')

SUPPORT_DEALER_AUTO_WITHDRAW = False

#: AD related
USE_ALIPAY_SYS_PROVIDER = True

ALIPAY_SYS_PROVIDER_ID = env('ALIPAY_SYS_PROVIDER_ID', '2088921710507475')

DEFAULT_ALIPAY_APP_ID = env('DEFAULT_ALIPAY_APP_ID', '2019061165493945')

DEALER_TRAFFIC_RECHARGE_APP_TYPE = 'saobei'

MY_WECHAT_USER_TOKEN = 'sLuJzxDQX2eE6xxD'

ID_SERVICE_IP = env('ID_SERVICE_IP', '')

ALIYUN_ACCESS_KEY_ID = 'LTAI4G8CcGDBcLnkYorDGBwH'
ALIYUN_ACCESS_KEY_SECRET = 'hfjbbfZ8T14A1ghxFlVUVGGIYdcdyp'
ALIYUN_CHANNEL_ID = 'QD-WHWF-310495'

INFLUXDB_DB = env('INFLUXDB_DB', 'washpayer')
INFLUXDB_USER = env('INFLUXDB_USER', 'root')
INFLUXDB_PWD = env('INFLUXDB_PWD', 'root')
INFLUXDB_IP = env('INFLUXDB_IP', '172.16.247.184')
INFLUXDB_PORT = env('INFLUXDB_PORT', '8086')

USE_PRIVATE_MQTT = bool(env('USE_PRIVATE_MQTT', 'True') == 'True')

OSS_RESOURCE_URL = 'https://resource.washpayer.com'

LOCAL_REPORT_URL = 'http://121.41.75.233'

ALI_OSS_ACCESS_ID = 'LTAI4GAwTnSbYY3rzkQUyJs5'
ALI_OSS_ACCESS_KEY = 'nQLJ7xV5S7L5ZC7EsEGGo61sVIKVZ7'
ALI_OSS_BUKET_NAME = 'oss-washpayer-1'
ALI_OSS_ENDPOINT = 'oss-cn-hangzhou-internal.aliyuncs.com'

FLUENTED_IP = env('FLUENTED_IP', '172.16.247.184')
FLUENTED_SIGNAL_PORT = 15160
FLUENTED_OFFLINE_PORT = 15161
FLUENTED_POWER_PORT = 15162

# 阿里 聚合拉新 CPA
ALIPAY_LAXIN_CHANNEL_ID = 'QD-WHWF-310495'

# 阿里 天猫入会 CPA
ALIPAY_RUHUI_CHANNEL_ID = 'QD-WHWF-310495'

# 对接山东平台的加密秘钥以及秘钥向量
AES_CBC_DATA_SECRET = "EDFGCEJISRWDZGME"
AES_CBC_DATA_SECRET_IV = "QJDBKGGRQQHTDSXW"
SHAN_DONG_TOKEN_SECRET = "987654WSFASFSASADSADFAS"

# 对接丰图平台的加密密钥
FENG_TU_TOKEN_SECRET = "880J3FY2F409ERT2458O45HR45OPGQ45"

UPLOAD_REPORT_TO_OSS = True

CAR_TCPIP_SERVER = env('CAR_TCPIP_SERVER', '127.0.0.1')
CAR_TCPIP_SERVER_PORT = int(env('CAR_TCPIP_SERVER_PORT', '50000'))

SKIP_HANDLE_WECHAT_COMPLAINT_TASK = True
ENABLE_REQUEST_LIMIT = True

# 阿里的银行卡识别appid
ALI_BANK_CARD_APP_CODE = "8296fcd952e34713ba91fbdceb13e915"
# 百度的图片识别app
BAIDU_IMAGE_RECOGNIZE_APP_ID = "24623149"
BAIDU_IMAGE_RECOGNIZE_APP_KEY = "mWuASxCCFsEngqlvH4y7opdx"
BAIDU_IMAGE_RECOGNIZE_APP_SECRET = "jgDs65aUTdZ077hmGdPXYPGk1NCxQjLO"

# TODO zjl 修改URL 链接方式或者使用.env 文件配置
def init_archive_database():
    from pymongo import MongoClient

    _databaseInfo = list()
    with MongoClient(host = env('MONGODB_IP'), port = int(env('MONGODB_PORT'))) as _client:
        _db = _client[env('MONGODB_WASHPAY_NAME')]
        _db.authenticate(name = env('MONGODB_WASHPAY_USER'),
                         password = env('MONGODB_WASHPAY_PASSWORD'),
                         source = env('MONGODB_WASHPAY_AUTH_DB'))

        for _item in _db["ArchivedDatabaseConfig"].find({"active": True}):
            _databaseInfo.append({
                "alias": _item.get("alias"),
                "name": _item.get("name"),
                "host": _item.get("host"),
                "port": _item.get("port"),
                "username": _item.get("username"),
                "password": _item.get("password"),
                "authentication_source": _item.get("authentication_source")
            })

    conns = map(lambda x: MongoCollection(**x), _databaseInfo)
    register_connections(*conns)


init_archive_database()


# 阿里云v3.0接口
ALIPAY_CHANNEL_ID_V3 = '619191980501444609'  # 主体ID
ALIPAY_MEDIA_ID_V3 = '707566730122012672'  # 媒体ID
ALIPAY_IMP_CPM_V3 = '755796924816712705'
ALIPAY_IMP_CPA_RUHUI_V3 = '773604407794823173'
ALIPAY_IMP_CPA_LAXIN_V3 = '773837769738319876'

CELERY_PUBLISH_METHOD = os.environ.get('CELERY_PUBLISH_METHOD', 'gevent')

ALI_ISV_APP_ID = '2021001191645419'