def obtain_coupon(coupon_id):
coupon = Coupon.get(coupon_id)
if not coupon:
return
if not coupon.is_owner(request.oauth.user):
abort(403, '用户不可使用此券')
return coupon
def obtain_coupon(coupon_id, user):
coupon = Coupon.get(coupon_id)
if not coupon:
return
if not coupon.is_owner(user):
raise CouponOwnershipError()
return coupon
def test_get_coupon(self, coupon_kind_get, package_get):
coupon_kind_get.return_value = self.coupon_kind
package_get.return_value = self.package
c = Coupon.create(name=u'呵呵哒',
kind=self.coupon_kind,
package=self.package,
product_matcher_kind=self.product_matcher_kind,
available_platforms=[Platform.web],
expire_time=datetime.now() + self.expires_in)
existence = Coupon.get(c.id_)
assert existence == c
id_list = Coupon.get_ids_by_user(c.user.id_)
assert c.id_ in id_list
id_list = Coupon.get_ids_by_package(c.package.id_)
assert c.id_ in id_list
def order():
"""认购产品"""
# 基础数据
due_date = None
profile = ZhiwangProfile.add(g.user.id_) if g.user else abort(401)
bankcard_id = request.form.get('bankcard_id', type=int) or abort(400)
bankcard = profile.bankcards.get(bankcard_id) or abort(400)
if Partner.zw not in bankcard.bank.available_in:
abort(400, 'unsupported bankcard')
coupon_id = request.form.get('coupon_id', type=int, default=0)
coupon = Coupon.get(coupon_id)
if coupon and not coupon.is_owner(g.user):
abort(403)
product_id = request.form.get('product_id', type=int, default=0)
product = ZhiwangProduct.get(product_id) or abort(404)
wrapped_product_id = request.form.get('wrapped_product_id', type=int)
wrapped_product = ZhiwangWrappedProduct.get(wrapped_product_id)
if wrapped_product and not wrapped_product.is_qualified(g.user.id_):
abort(401)
# 选择表单验证
form = select_subscribe_form(wrapped_product or product)()
if not form.validate():
return jsonify(r=False, error=form.errors.values()[0][0])
# 只有房贷宝产品才有到期日
if product.product_type is ZhiwangProduct.Type.fangdaibao:
due_date = wrapped_product.due_date if wrapped_product else form.data[
'due_date']
# 设置购买卡为默认卡
profile.bankcards.set_default(bankcard)
# 申购产品
try:
order = subscribe_product(
g.user,
product,
bankcard,
form.data['order_amount'],
form.data['pay_amount'],
due_date,
wrapped_product=wrapped_product,
coupon=coupon,
pocket_deduction_amount=form.data['pocket_deduction_amount'])
except (SoldOutError, SuspendedError, OffShelfError, OutOfRangeError,
InvalidIdentityError, ExceedBankAmountLimitError,
SubscribeProductError, CouponBusinessError,
FirewoodBusinessError) as e:
return jsonify(r=False, error=unicode(e))
payment_url = url_for('.pay',
order_code=order.order_code,
pay_code=order.pay_code)
return jsonify(r=True, payment_url=payment_url)
def order():
"""认购产品"""
# 基础数据
profile = XMProfile.add(g.user.id_) if g.user else abort(401)
bankcard_id = request.form.get('bankcard_id', type=int) or abort(400)
bankcard = profile.bankcards.get(bankcard_id) or abort(400)
if Partner.xm not in bankcard.bank.available_in:
abort(400, 'unsupported bankcard')
coupon_id = request.form.get('coupon_id', type=int, default=0)
coupon = Coupon.get(coupon_id)
if coupon and not coupon.is_owner(g.user):
abort(403)
product_id = request.form.get('product_id', type=int, default=0)
product = XMFixedDuedayProduct.get(product_id) or abort(404)
# 选择表单验证
form = select_subscribe_form(product)()
if not form.validate():
return jsonify(r=False, error=form.errors.values()[0][0])
# 设置购买卡为默认卡
profile.bankcards.set_default(bankcard)
# 申购产品
try:
order = subscribe_product(
g.user,
product,
bankcard,
form.data['order_amount'],
form.data['pay_amount'],
product.due_date,
coupon=coupon,
pocket_deduction_amount=form.data['pocket_deduction_amount'])
except (SoldOutError, SuspendedError, OffShelfError, OutOfRangeError,
InvalidIdentityError, ExceedBankAmountLimitError,
SubscribeProductError, CouponBusinessError,
FirewoodBusinessError) as e:
return jsonify(r=False, error=unicode(e))
payment_url = url_for('.pay',
order_code=order.order_code,
pay_code=order.pay_code)
return jsonify(r=True, payment_url=payment_url)
def test_check_usage(self, kind, outdated, product_matcher_kind_get):
product_matcher_kind_get.return_value = self.product_matcher_kind
coupon = Coupon.create(name=u'呵呵哒',
kind=self.coupon_kind,
package=self.package,
product_matcher_kind=self.product_matcher_kind,
available_platforms=[Platform.web],
expire_time=datetime(2015, 1, 1))
with raises(CouponOutdatedError):
coupon.check_before_use()
Coupon.outdated = False
coupon.product_matcher.is_available_for_product.return_value = False
with raises(UnsupportedProductError):
coupon.check_before_use(product='test')
coupon.regulation.is_available_for_order.return_value = False
with raises(IneligibleOrderError):
coupon.check_before_use(amount=3000)
def test_new_coupon(self, coupon_kind_get, package_get):
coupon_kind_get.return_value = self.coupon_kind
package_get.return_value = self.package
c = Coupon.create(name=u'呵呵哒',
kind=self.coupon_kind,
package=self.package,
product_matcher_kind=self.product_matcher_kind,
available_platforms=[Platform.web],
expire_time=datetime.now() + self.expires_in)
assert c.name == u'呵呵哒'
assert c.user == self.account
assert c.kind == self.coupon_kind
assert c.status is Coupon.Status.in_wallet
assert c.package == self.package
assert Platform.web in c.platforms
coupon_kind_get.assert_called_once_with('101')
package_get.assert_called_once_with('303')
def test_transfer_status(self):
coupon = Coupon.create(name=u'呵呵哒',
kind=self.coupon_kind,
package=self.package,
product_matcher_kind=self.product_matcher_kind,
available_platforms=[Platform.web],
expire_time=datetime.now() + self.expires_in)
coupon.shell_out()
assert coupon.status is Coupon.Status.stocktaking
coupon.put_back_wallet()
assert coupon.status is Coupon.Status.in_wallet
coupon.shell_out()
coupon.confirm_consumption()
assert coupon.status is Coupon.Status.consumed
with raises(InvalidCouponStatusTransferError):
coupon.put_back_wallet()
with raises(InvalidCouponStatusTransferError):
coupon.confirm_consumption()
def get_related_coupons(self):
from ..coupon import Coupon
return Coupon.get_multi_by_package(self)
def unpack(self,
user,
reserved_sha1=None,
allow_piling_firewood=True,
dynamic_firewood_worth=None):
"""Unpacks package to get coupons.
:param user: The user who gained this package.
:param reserved_sha1: Optional. The reserved SHA1 token.
"""
from core.models.welfare import Coupon, FirewoodWorkflow
self._check_status_transfer(
(self.Status.in_air, self.Status.under_foot),
self.Status.in_pocket)
# checks for reserved package
if self.status is self.Status.under_foot:
if reserved_sha1 is None:
raise ValueError('reserved_sha1 is required')
if not safe_str_cmp(reserved_sha1, self.reserved_sha1):
raise WrongPackageTokenError('reserved_sha1 is wrong')
if self.status is self.Status.in_air and reserved_sha1 is not None:
raise ValueError('coupon package has not been reserved')
# checks with strategy
if self.kind.distributor and not self.kind.distributor.can_unpack(
user=user, package=self):
raise PackageDistributorDenied('distributor denied', self.id_)
self.user_id = user.id_
self.status = self.Status.in_pocket
self.unpacked_time = datetime.now()
sql = ('update {.table_name} set user_id=%s, status=%s, '
'unpacked_time=%s where id=%s').format(self)
params = (self.user_id, self.status.value, self.unpacked_time,
self.id_)
db.execute(sql, params)
db.commit()
# release coupon here
if self.kind.coupon_wrappers:
try:
for wrapper in self.kind.coupon_wrappers:
for _ in xrange(wrapper.amount):
Coupon.create(wrapper.name,
wrapper.kind,
self,
wrapper.product_matcher_kind,
wrapper.platforms,
wrapper.expire_time,
_commit=False)
except:
db.rollback()
raise
else:
db.commit()
# pile fire woods
if allow_piling_firewood and self.kind.firewood_wrapper:
FirewoodWorkflow(user.id_).pile(
user,
self.kind.firewood_wrapper.worth,
self,
tags=[self.kind.firewood_wrapper.name])
self.clear_cache(self.id_)
self.clear_cache_by_user(self.user_id)