def test_discard(self):
def create_bankcard_in_the_same_bank():
return BankCard.add(self.local_account.id, '13800138000',
'6222980000010001', '1', '440113', '440000',
'大望路支行', False)
with patch('core.models.profile.bankcard.DEBUG', True):
bankcard = BankCard.add(self.local_account.id, '13800138000',
'6222980000000002', '1', '440113',
'440000', '大望路支行', False)
with raises(BankConflictError):
create_bankcard_in_the_same_bank()
bankcard.discard()
assert self.bankcards.get_all() == []
assert self.bankcards.get_latest() is None
assert self.bankcards.get_last_used() is None
new_bankcard = create_bankcard_in_the_same_bank()
assert new_bankcard
card_ids = {c.id_ for c in self.bankcards.get_all()}
assert bankcard.id_ not in card_ids
assert new_bankcard.id_ in card_ids
assert BankCard.get(bankcard.id_).status is BankCard.Status.discarded
assert self.bankcards.get_latest().id_ == new_bankcard.id_
assert self.bankcards.get_last_used().id_ == new_bankcard.id_
def test_bank_card_manager(self):
with patch('core.models.profile.bankcard.DEBUG', True):
b1 = BankCard.add(self.local_account.id, '13800138000',
'6222980000000002', '1', '440113', '440000',
'大望路支行', False)
b2 = BankCard.add(self.local_account.id, '13800138001',
'6222980000010001', '2', '440113', '440000',
'大望路支行', False)
cards = self.bankcards.get_all()
assert len(cards) == 2
assert cards[0].mobile_phone == b1.mobile_phone
assert cards[0].card_number == b1.card_number
assert cards[0].local_bank_name == b1.local_bank_name
assert cards[1].mobile_phone == b2.mobile_phone
assert cards[1].card_number == b2.card_number
assert cards[1].local_bank_name == b2.local_bank_name
self.bankcards.add(mobile_phone='13800138002',
card_number='6222980000030009',
bank_id='3',
city_id='440113',
province_id='440000',
local_bank_name='西二旗支行',
is_default=False)
cards = self.bankcards.get_all()
assert len(cards) == 3
assert cards[2].mobile_phone == '13800138002'
assert cards[2].card_number == '6222980000030009'
assert cards[2].local_bank_name == '西二旗支行'
def test_create(self):
with patch('core.models.profile.bankcard.DEBUG', True):
b1 = BankCard.add(self.local_account.id, '13800138000',
'6222980000000002', '1', '440113', '440000',
'大望路支行', True)
b2 = BankCard.add(self.local_account.id, '13800138001',
'6222980000010001', '2', '440113', '440000',
'西二旗支行', False)
assert b1
assert b2
bank_card = BankCard.get(b1.id_)
assert bank_card.mobile_phone == '13800138000'
assert bank_card.card_number == '6222980000000002'
assert bank_card.city_id == '440113'
assert bank_card.province_id == '440000'
assert bank_card.local_bank_name == '大望路支行'
assert bank_card.is_default
bank_card = BankCard.get(b2.id_)
assert bank_card.mobile_phone == '13800138001'
assert bank_card.card_number == '6222980000010001'
assert bank_card.city_id == '440113'
assert bank_card.province_id == '440000'
assert bank_card.local_bank_name == '西二旗支行'
assert bank_card.is_default is False
def check_before_adding(cls, user_id, product_id, bankcard_id, amount):
product = PlaceboProduct.get(product_id)
bankcard = BankCard.get(bankcard_id)
user = Account.get(user_id)
# 检查关联对象
for attr_name, attr in [('product_id', product),
('bankcard_id', bankcard), ('user_id', user)]:
if not attr:
raise ValueError('invalid %s' % attr_name)
# 检查身份认证
if not has_real_identity(user):
raise InvalidIdentityError()
# 检查产品是否可售
if not product.strategy.target(user_id):
raise InvalidProductError(product_id) # 策略拒绝
if not product.in_stock:
raise OffShelfError(product_id) # 下架
# 检查金额范围
if amount is None and product.min_amount == product.max_amount:
amount = product.min_amount
if (amount.is_nan() or amount < product.min_amount
or amount > product.max_amount):
raise OutOfRangeError(amount,
(product.min_amount, product.max_amount))
return user, product, bankcard, amount
def initialize_with_bankcard(self, bankcard_id):
"""Initializes with bankcard.
:param bankcard_id: The default bankcard used in third-party account.
:raises UnsupportedBankError: if the bank of choosen bankcard is not
supported.
"""
self.bankcard = BankCard.get(bankcard_id)
if not self.bankcard:
raise ProgrammingError('bankcard %r not found' % bankcard_id)
self.bankcard.bank.raise_for_unavailable(self.provider.bank_partner)
def generate_fake_transactions():
user = Account.get_by_alias('*****@*****.**')
if not user:
return
with patch('core.models.profile.bankcard.DEBUG', True):
b1 = BankCard.add(
user_id=user.id_,
mobile_phone='13800138000',
card_number='6222000000000009',
bank_id='4', # 建设银行
city_id='110100', # 朝阳
province_id='110000', # 北京
local_bank_name='西夏支行',
is_default=True)
b2 = BankCard.add(
user_id=user.id_,
mobile_phone='13800138000',
card_number='6222000000010008',
bank_id='10002', # 中信银行
city_id='110100', # 朝阳
province_id='110000', # 北京
local_bank_name='天龙寺支行',
is_default=True)
bcolors.run(repr(b1), key='wallet')
bcolors.run(repr(b2), key='wallet')
wallet_account = WalletAccount.get_or_add(user, zhongshan)
t1 = WalletTransaction.add(
wallet_account, b1, decimal.Decimal('40'),
WalletTransaction.Type.purchase, uuid.uuid4().hex, WalletTransaction.Status.failure)
t2 = WalletTransaction.add(
wallet_account, b1, decimal.Decimal('42'),
WalletTransaction.Type.purchase, uuid.uuid4().hex, WalletTransaction.Status.success)
t3 = WalletTransaction.add(
wallet_account, b2, decimal.Decimal('10'),
WalletTransaction.Type.redeeming, uuid.uuid4().hex, WalletTransaction.Status.success)
bcolors.run(repr(t1), key='wallet')
bcolors.run(repr(t2), key='wallet')
bcolors.run(repr(t3), key='wallet')
def add_bankcard(self,
user_id,
bank_id='10005',
card_number='6222980000000002',
mobile_phone='13800138000',
division_code='440300',
local_bank_name=u'深大支行',
is_default=False):
from core.models.profile.bankcard import BankCard
with patch('core.models.profile.bankcard.DEBUG', True):
province_code = division_code[:2] + '00'
prefecture_code = division_code[:4] + '00'
return BankCard.add(user_id, mobile_phone, card_number, bank_id,
prefecture_code, province_code,
local_bank_name, is_default)
def restore_bankcard(self, force=False):
if not self.bankcard_id:
raise ValueError('missing bankcard_id')
try:
return BankCard.restore(self.bankcard_id, self.user_id)
except BankCardChanged as e:
if force:
new_bankcard_id = e.args[0]
self.migrate_bankcard(self.bankcard_id, new_bankcard_id)
self.bankcard_id = new_bankcard_id
try:
del self.bankcard
except AttributeError:
pass
return self.bankcard
else:
raise
def test_failed_to_create(self):
with patch('core.models.profile.bankcard.DEBUG', True):
BankCard.add(self.local_account.id, '13800138000',
'6222980000000002', '1', '440113', '440000', '大望路支行',
False)
with raises(CardConflictError):
BankCard.add(self.local_account.id, '13800138000',
'6222980000000002', '2', '440113', '440000',
'大望路支行', False)
with raises(BankConflictError):
BankCard.add(self.local_account.id, '13800138000',
'6222980000010001', '1', '440113', '440000',
'大望路支行', False)
def check_before_adding(cls, vendor, user_id, bankcard_id, product_id,
amount):
if not vendor:
raise NotFoundEntityError(vendor.id_, Account)
product = HoarderProduct.get(product_id)
local_account = Account.get(user_id)
bankcard = BankCard.get(bankcard_id)
hoarder_account = HoarderAccount.get(vendor.id_, user_id)
if not local_account:
raise NotFoundEntityError(user_id, Account)
if not bankcard:
raise NotFoundEntityError(bankcard_id, BankCard)
if not hoarder_account:
raise UnboundAccountError(user_id)
if not has_real_identity(local_account):
raise InvalidIdentityError()
# 产品是否处于可售状态
if product.is_sold_out:
raise SoldOutError(product_id)
# 产品是否处于正常销售状态
if product.is_taken_down:
raise SuspendedError(product_id)
# 产品是否处于在售状态
if not product.is_on_sale:
raise OffShelfError(product_id)
# checks the product amount limit
if not isinstance(amount, Decimal):
raise TypeError('order amount must be decimal')
amount_range = (product.min_amount, product.max_amount)
amount_check = [
amount.is_nan(), amount < 0, amount < amount_range[0],
amount > amount_range[1]
]
if any(amount_check):
raise OutOfRangeError(amount, amount_range)
def check_before_adding(cls, user_id, bankcard_id, product_id, amount):
product = XMFixedDuedayProduct.get(product_id)
bankcard = BankCard.get(bankcard_id)
local_account = Account.get(user_id)
xm_account = XMAccount.get_by_local(user_id)
# checks the related entities
if not bankcard:
raise NotFoundError(bankcard_id, BankCard)
if not local_account:
raise NotFoundError(local_account, Account)
if not xm_account:
raise UnboundAccountError(user_id)
# checks the identity
if not has_real_identity(local_account):
raise InvalidIdentityError
# 产品是否处于可售状态
if product.is_sold_out:
raise SoldOutError(product_id)
# 产品是否处于正常销售状态
if product.is_taken_down:
raise SuspendedError(product_id)
# 产品是否处于在售状态
if not product.in_stock:
raise OffShelfError(product_id)
# checks the product amount limit
if not isinstance(amount, Decimal):
raise TypeError('order amount must be decimal')
amount_range = (product.min_amount, product.max_amount)
amount_check = [amount.is_nan(),
amount < 0,
amount < amount_range[0],
amount > amount_range[1]]
if any(amount_check):
raise OutOfRangeError(amount, amount_range)
def test_delete_and_restore(self):
with patch('core.models.profile.bankcard.DEBUG', True):
b1 = BankCard.add(self.local_account.id, '13800138000',
'6222980000000002', '1', '440113', '440000',
'大望路支行', False)
assert b1
BankCard.delete_by_card_number('6222980000000002',
self.local_account.id)
b2 = BankCard.get(b1.id_)
assert b2 is None
BankCard.restore(b1.id_, self.local_account.id)
b3 = BankCard.get(b1.id_)
assert b3
assert b3.mobile_phone == '13800138000'
assert b3.card_number == '6222980000000002'
assert b3.city_id == '440113'
assert b3.province_id == '440000'
assert b3.local_bank_name == '大望路支行'
def check_before_adding(cls,
user_id,
bankcard_id,
product_id,
amount,
wrapped_product_id=None):
product = ZhiwangProduct.get(product_id)
wrapped_product = ZhiwangWrappedProduct.get(
wrapped_product_id) if wrapped_product_id else None
# check the product and wrapped_product
if wrapped_product_id is not None and not wrapped_product:
raise NotFoundError(wrapped_product_id, ZhiwangWrappedProduct)
if wrapped_product and wrapped_product.raw_product.product_id != product_id:
raise UnknownProductInheritance(product_id, wrapped_product_id)
if wrapped_product and not wrapped_product.is_qualified(user_id):
raise IneligiblePurchase(user_id, wrapped_product_id)
product = wrapped_product if wrapped_product else product
bankcard = BankCard.get(bankcard_id)
local_account = Account.get(user_id)
zhiwang_account = ZhiwangAccount.get_by_local(user_id)
# checks the related entities
if not bankcard:
raise NotFoundError(bankcard_id, BankCard)
if not local_account:
raise NotFoundError(local_account, Account)
if not zhiwang_account:
raise UnboundAccountError(user_id)
# checks the identity
if not has_real_identity(local_account):
raise InvalidIdentityError
# 产品是否处于可售状态
if product.is_either_sold_out:
raise SoldOutError(product_id, wrapped_product_id)
# 产品是否处于正常销售状态
if product.is_taken_down:
raise SuspendedError(product_id, wrapped_product_id)
# 产品是否处于在售状态
if not product.in_stock:
raise OffShelfError(product_id, wrapped_product_id)
# checks the product amount limit
if not isinstance(amount, Decimal):
raise TypeError('order amount must be decimal')
amount_range = (product.min_amount, product.max_amount)
amount_check = [
amount.is_nan(), amount < 0, amount < amount_range[0],
amount > amount_range[1]
]
if any(amount_check):
raise OutOfRangeError(amount, amount_range)
# checks the bank amount limit
bank_limit = bankcard.bank.zwlib_amount_limit
bank_limit = max(bank_limit) if cls.is_bankcard_swiped(
bankcard) else min(bank_limit)
if amount > bank_limit:
raise ExceedBankAmountLimitError(amount, bank_limit)
def bankcard(self):
if not self.bankcard_id:
return
return BankCard.get(self.bankcard_id)
def create_bankcard_in_the_same_bank():
return BankCard.add(self.local_account.id, '13800138000',
'6222980000010001', '1', '440113', '440000',
'大望路支行', False)
def __call__(self, form, field):
message = field.gettext(self.message)
try:
BankCard.validate_card_number(field.data)
except ValueError:
raise wtforms.validators.ValidationError(message)
def bankcard(self):
return BankCard.get(self.bankcard_id)
def bank_card(self):
return BankCard.get(self.order.bankcard_id) if self.order else ''
def profile_bankcard(sqlstore, couchstore, redis):
with patch('core.models.profile.bankcard.DEBUG', True):
return BankCard.add('1', '13800138000', '6222980000000002', '1',
'440113', '440000', '大望路支行', True)
def get_multi_by_user(cls, user_id, provider):
bankcards = BankCard.get_multi_by_user(user_id)
generator = (cls.get_by_bankcard(b, provider) for b in bankcards)
return [binding for binding in generator if binding]
def _validated(self, value):
try:
BankCard.validate_card_number(value)
except ValueError:
raise ValidationError(u'该银行卡号无效，请修改后重试')
return value
def remove_bankcard(user_id, bankcard_id):
profile = ZhiwangProfile.add(user_id)
bankcard = BankCard.get(bankcard_id)
if not bankcard:
return
profile.bankcards.remove(bankcard.card_number, silent=True)
