def get_order_items():
# get the order items for this customer from the latest order that isn't signed yet
service_user = users.get_current_user()
customer = get_customer(service_user)
if not customer:
return []
order_key = Order.create_key(customer.id,
Order.CUSTOMER_STORE_ORDER_NUMBER)
order = Order.get(order_key)
if order:
sln_settings = get_solution_settings(service_user)
lang = sln_settings.main_language
remaining_length, sub_order = get_subscription_order_remaining_length(
customer.id, customer.subscription_order_number)
subscription_order_charge_date = format_date(
datetime.datetime.utcfromtimestamp(sub_order.next_charge_date),
locale=lang)
order_items = list(OrderItem.list_by_order(order_key))
order_items_updated = list()
to_put = list()
to_get = list(
set([Product.create_key(o.product_code) for o in order_items] +
[Product.create_key(Product.PRODUCT_EXTRA_CITY)]))
products = {p.code: p for p in db.get(to_get)}
# update the order items if necessary.
for order_item in order_items:
if products[
order_item.
product_code].is_subscription_extension and order_item.count != remaining_length:
order_item.count = remaining_length
to_put.append(order_item)
order_items_updated.append(order_item)
if to_put:
db.put(to_put)
extra_city_price = format_price(
products[Product.PRODUCT_EXTRA_CITY].price, sln_settings.currency)
service_visible_in_translation = translate(
lang,
SOLUTION_COMMON,
'service_visible_in_app',
subscription_expiration_date=subscription_order_charge_date,
amount_of_months=remaining_length,
extra_city_price=extra_city_price,
app_name='%(app_name)s')
return [
OrderItemTO.create(i, service_visible_in_translation)
for i in order_items_updated
]
else:
return []
def get_products():
service_user = users.get_current_user()
sln_settings = get_solution_settings(service_user)
keys = [
Product.create_key('BEAC'),
Product.create_key('POSM'),
Product.create_key(Product.PRODUCT_CARDS)
]
if SolutionModule.CITY_APP not in sln_settings.modules: # city apps cannot order more city apps
keys.append(Product.create_key(Product.PRODUCT_EXTRA_CITY))
else:
keys.append(Product.create_key(Product.PRODUCT_ROLLUP_BANNER))
return [
ProductTO.create(p, sln_settings.main_language)
for p in Product.get(keys)
]
def test_customer_store(self):
xcty_product = ShopProductTO.create(u'be-berlare', u'XCTY', 1)
posm_product = ShopProductTO.create(MISSING, u'POSM', 250)
_, customer = self._create_customer_and_subscription_order(
[u'MSUP', u'BEAC', u'KSUP', u'ILOS'])
self._create_service(customer)
customer = Customer.get_by_id(customer.id)
self.current_user = users.User(customer.service_email)
set_current_user(self.current_user)
product_xcty, product_posm = db.get(
[Product.create_key(u'XCTY'),
Product.create_key(u'POSM')])
xcty_order_item = add_item_to_order(xcty_product).order_item
remaining_subscription_length = get_subscription_order_remaining_length(
customer.id, customer.subscription_order_number)[0]
price_xcty = remaining_subscription_length * product_xcty.price
temp_order = Order.get_by_order_number(customer.id, '-1')
self.assertEqual(temp_order.is_subscription_order, False)
self.assertEqual(temp_order.amount, price_xcty)
self.assertEqual(temp_order.is_subscription_extension_order,
False) # Is set when paying the order
add_item_to_order(posm_product).order_item
temp_order = Order.get_by_order_number(customer.id, '-1')
self.assertEqual(temp_order.amount,
price_xcty + product_posm.price * 250)
# test removing an order item
remove_from_order(xcty_order_item.id)
temp_order = Order.get_by_order_number(customer.id, '-1')
self.assertEqual(temp_order.amount, product_posm.price * 250)
xcty_order_item = add_item_to_order(xcty_product).order_item
temp_order = Order.get_by_order_number(customer.id, '-1')
self.assertEqual(temp_order.amount,
price_xcty + product_posm.price * 250)
self.assertEqual(
pay_order().success,
False) # should be false since we have no credit card linked
def create_and_pay_news_order(service_user, news_item_id, order_items_to):
"""
Creates an order, orderitems, charge and executes the charge. Should be executed in a transaction.
Args:
service_user (users.User)
news_item_id (long)
order_items_to (ist of OrderItemTO)
Raises:
NoCreditCardException
ProductNotFoundException
"""
@db.non_transactional
def _get_customer():
return get_customer(service_user)
@db.non_transactional
def _get_contact():
return Contact.get_one(customer)
customer = _get_customer()
azzert(customer)
contact = _get_contact()
azzert(contact)
if not customer.stripe_valid:
raise NoCreditCardException(customer)
extra_city_product_key = Product.create_key(Product.PRODUCT_EXTRA_CITY)
news_product_key = Product.create_key(Product.PRODUCT_NEWS_PROMOTION)
rmt_key = RegioManagerTeam.create_key(customer.team_id)
extra_city_product, news_promotion_product, team = db.get(
(extra_city_product_key, news_product_key, rmt_key))
azzert(extra_city_product)
azzert(news_promotion_product)
azzert(team)
new_order_key = Order.create_key(customer.id,
OrderNumber.next(team.legal_entity_key))
vat_pct = get_vat_pct(customer, team)
total_amount = 0
added_app_ids = []
for order_item in order_items_to:
if order_item.product == Product.PRODUCT_EXTRA_CITY:
total_amount += extra_city_product.price * order_item.count
added_app_ids.append(order_item.app_id)
order_item.price = extra_city_product.price
elif order_item.product == Product.PRODUCT_NEWS_PROMOTION:
total_amount += news_promotion_product.price * order_item.count
order_item.price = news_promotion_product.price
else:
raise BusinessException('Invalid product \'%s\'' %
order_item.product)
si = get_default_service_identity(users.User(customer.service_email))
if added_app_ids:
keys = [App.create_key(app_id) for app_id in added_app_ids]
apps = db.get(keys)
for app_id, app in zip(added_app_ids, apps):
if not app:
raise AppNotFoundException(app_id)
if app_id in si.appIds:
raise BusinessException('Customer %s already has app_id %s' %
(customer.id, app_id))
vat = int(round(vat_pct * total_amount / 100))
total_amount_vat_incl = int(round(total_amount + vat))
now_ = now()
to_put = []
order = Order(key=new_order_key,
date=now_,
amount=total_amount,
vat_pct=vat_pct,
vat=vat,
total_amount=total_amount_vat_incl,
contact_id=contact.id,
status=Order.STATUS_SIGNED,
is_subscription_order=False,
is_subscription_extension_order=False,
date_signed=now_,
manager=STORE_MANAGER,
team_id=team.id)
to_put.append(order)
azzert(order.total_amount >= 0)
for item in order_items_to:
order_item = OrderItem(parent=new_order_key,
number=item.number,
product_code=item.product,
count=item.count,
comment=item.comment,
price=item.price)
order_item.app_id = item.app_id
if order_item.product_code == Product.PRODUCT_NEWS_PROMOTION:
order_item.news_item_id = news_item_id
to_put.append(order_item)
db.put(to_put)
# Not sure if this is necessary
deferred.defer(generate_and_put_order_pdf_and_send_mail,
customer,
new_order_key,
service_user,
_transactional=True)
# No need for signing here, immediately create a charge.
to_put = []
charge = Charge(parent=new_order_key)
charge.date = now()
charge.type = Charge.TYPE_ORDER_DELIVERY
charge.amount = order.amount
charge.vat_pct = order.vat_pct
charge.vat = order.vat
charge.total_amount = order.total_amount
charge.manager = order.manager
charge.team_id = order.team_id
charge.status = Charge.STATUS_PENDING
charge.date_executed = now()
charge.currency_code = team.legal_entity.currency_code
to_put.append(charge)
# Update the regiomanager statistics so these kind of orders show up in the monthly statistics
deferred.defer(update_regiomanager_statistic,
gained_value=order.amount / 100,
manager=order.manager,
_transactional=True)
# Update the customer service
si.appIds.extend(added_app_ids)
to_put.append(si)
# Update the customer object so the newly added apps are added.
customer.app_ids.extend(added_app_ids)
customer.extra_apps_count += len(added_app_ids)
to_put.append(customer)
db.put(to_put)
deferred.defer(re_index, si.user)
# charge the credit card
if charge.total_amount > 0:
get_payed(customer.id, order, charge)
server_settings = get_server_settings()
send_to = server_settings.supportWorkers
send_to.append(MC_DASHBOARD.email())
channel_data = {
'customer': customer.name,
'no_manager': True,
'amount': charge.amount / 100,
'currency': charge.currency
}
channel.send_message(map(users.User, send_to),
'shop.monitoring.signed_order',
info=channel_data)
else:
charge.status = Charge.STATUS_EXECUTED
charge.date_executed = now()
charge.put()
channel.send_message(service_user, 'common.billing.orders.update')
def trans():
charge = None
expired_subscription, customer = db.get([ExpiredSubscription.create_key(customer_id),
Customer.create_key(customer_id)])
expired_subscription.status = status
expired_subscription.status_updated_timestamp = now()
if status == ExpiredSubscription.STATUS_WILL_LINK_CREDIT_CARD:
# Create a task for regiomanager to check if the customer has linked his credit card after two weeks.
# the ExpiredSubscription object from this customer will be cleaned up in recurrentbilling the day after he has linked it.
to_put.append(expired_subscription)
team, prospect = db.get([RegioManagerTeam.create_key(customer.team_id),
Prospect.create_key(customer.prospect_id)])
execution_time = now() + DAY * 14
date_string = datetime.datetime.utcfromtimestamp(execution_time).strftime(u'%A %d %b %Y')
comment = u'Check if the customer has linked his creditcard (for automatic subscription renewal).' \
u' If he hasn\'t linked it before %s, contact him again.' % date_string
task = create_task(current_user.email(), prospect, team.support_manager, execution_time,
ShopTask.TYPE_CHECK_CREDIT_CARD, prospect.app_id, comment=comment)
to_put.append(task)
elif status == ExpiredSubscription.STATUS_EXTEND_SUBSCRIPTION:
# Creates a new charge using the customer his subscription order.
subscription_order, team = db.get([Order.create_key(customer.id, customer.subscription_order_number),
RegioManagerTeam.create_key(customer.team_id)])
extension_order_item_keys = list()
order_items = list(OrderItem.list_by_order(subscription_order.key()))
products_to_get = list()
for item in order_items:
products_to_get.append(Product.create_key(item.product_code))
products = {p.code: p for p in Product.get(products_to_get)}
# extend per year
months = 12
total_amount = 0
for item in order_items:
product = products[item.product_code]
if product.is_subscription and item.price > 0:
total_amount += months * item.price
elif not product.is_subscription and (product.is_subscription_discount or product.extra_subscription_months > 0):
total_amount += months * item.price
elif product.is_subscription_extension:
total_amount += months * item.price
extension_order_item_keys.append(item.key())
if total_amount <= 0:
raise BusinessException('The created charge has a negative amount (%d)' % total_amount)
next_charge_datetime = datetime.datetime.utcfromtimestamp(now()) + relativedelta(months=months)
subscription_order.next_charge_date = get_epoch_from_datetime(next_charge_datetime)
to_put.append(subscription_order)
# reconnect all previously connected friends if the service was disabled in the past
if customer.service_disabled_at != 0:
deferred.defer(set_service_enabled, customer.id, _transactional=True)
vat_pct = get_vat_pct(customer, team)
charge = Charge(parent=subscription_order)
charge.date = now()
charge.type = Charge.TYPE_SUBSCRIPTION_EXTENSION
charge.subscription_extension_length = months
charge.subscription_extension_order_item_keys = extension_order_item_keys
charge.amount = total_amount
charge.vat_pct = vat_pct
charge.vat = int(total_amount * vat_pct / 100)
charge.total_amount = charge.amount + charge.vat
charge.currency_code = team.legal_entity.currency_code
to_put.append(charge)
to_delete.append(expired_subscription)
db.put(to_put)
if to_delete:
db.delete(to_delete)
return charge
def trans():
old_order, team = db.get(
(old_order_key, RegioManagerTeam.create_key(customer.team_id)))
if not old_order:
return BoolReturnStatusTO.create(
False,
translate(
get_solution_settings(service_user).main_language,
SOLUTION_COMMON, u'cart_empty'), False)
# Duplicate the order
to_put = list()
to_delete = list()
properties = copy_model_properties(old_order)
properties['status'] = Order.STATUS_SIGNED
properties['date_signed'] = now()
new_order_key = Order.create_key(
customer.id, OrderNumber.next(team.legal_entity_key))
new_order = Order(key=new_order_key, **properties)
new_order.team_id = team.id
to_delete.append(old_order)
# duplicate all of the order items
old_order_items = OrderItem.list_by_order(old_order_key)
all_products = db.get([
Product.create_key(item.product_code) for item in old_order_items
])
is_subscription_extension_order = False
for product in all_products:
if product.is_subscription_extension:
is_subscription_extension_order = True
break
new_order.is_subscription_extension_order = is_subscription_extension_order
if is_subscription_extension_order:
subscription_order = Order.get_by_order_number(
customer.id, customer.subscription_order_number)
new_order.next_charge_date = subscription_order.next_charge_date
added_apps = list()
should_create_shoptask = False
for old_item in old_order_items:
properties = copy_model_properties(old_item)
new_item = OrderItem(parent=new_order_key, **properties)
to_put.append(new_item)
to_delete.append(old_item)
if hasattr(old_item, 'app_id'):
added_apps.append(old_item.app_id)
else:
should_create_shoptask = True
to_put.append(new_order)
db.put(to_put)
db.delete(to_delete)
deferred.defer(generate_and_put_order_pdf_and_send_mail,
customer,
new_order_key,
service_user,
_transactional=True)
# No need for signing here, immediately create a charge.
azzert(new_order.total_amount > 0)
charge = Charge(parent=new_order_key)
charge.date = now()
charge.type = Charge.TYPE_ORDER_DELIVERY
charge.amount = new_order.amount
charge.vat_pct = new_order.vat_pct
charge.vat = new_order.vat
charge.total_amount = new_order.total_amount
charge.manager = new_order.manager
charge.team_id = new_order.team_id
charge.status = Charge.STATUS_PENDING
charge.date_executed = now()
charge.currency_code = team.legal_entity.currency_code
charge.put()
# Update the regiomanager statistics so these kind of orders show up in the monthly statistics
deferred.defer(update_regiomanager_statistic,
gained_value=new_order.amount / 100,
manager=new_order.manager,
_transactional=True)
# Update the customer service
si = get_default_service_identity(users.User(customer.service_email))
si.appIds.extend(added_apps)
si.put()
deferred.defer(re_index, si.user, _transactional=True)
# Update the customer object so the newly added apps are added.
customer.app_ids.extend(added_apps)
customer.extra_apps_count += len(added_apps)
customer.put()
get_payed(customer.id, new_order, charge)
# charge the credit card
channel.send_message(service_user, 'common.billing.orders.update')
channel_data = {
'customer': customer.name,
'no_manager': True,
'amount': charge.amount / 100,
'currency': charge.currency
}
server_settings = get_server_settings()
send_to = server_settings.supportWorkers
send_to.append(MC_DASHBOARD.email())
channel.send_message(map(users.User, send_to),
'shop.monitoring.signed_order',
info=channel_data)
if should_create_shoptask:
prospect_id = customer.prospect_id
if prospect_id is None:
prospect = create_prospect_from_customer(customer)
prospect_id = prospect.id
deferred.defer(create_task_for_order,
customer.team_id,
prospect_id,
new_order.order_number,
_transactional=True)
return BoolReturnStatusTO.create(True, None)
def trans():
to_put = list()
customer_store_order_key = Order.create_key(
customer.id, Order.CUSTOMER_STORE_ORDER_NUMBER)
subscription_order_key = Order.create_key(
customer.id, customer.subscription_order_number)
team_key = RegioManagerTeam.create_key(customer.team_id)
product_key = Product.create_key(item.code)
if item.app_id is not MISSING:
app_key = App.create_key(item.app_id)
product, customer_store_order, sub_order, app, team = db.get([
product_key, customer_store_order_key, subscription_order_key,
app_key, team_key
])
if sub_order.status != Order.STATUS_SIGNED:
raise BusinessException(
translate(lang, SOLUTION_COMMON, u'no_unsigned_order'))
# check if the provided app does exist
azzert(app)
else:
product, customer_store_order, team = db.get(
[product_key, customer_store_order_key, team_key])
# Check if the item has a correct count.
# Should never happen unless the user manually recreates the ajax request..
azzert(
not product.possible_counts
or item.count in product.possible_counts
or item.code == Product.PRODUCT_EXTRA_CITY,
u'Invalid amount of items supplied')
number = 0
existing_order_items = list()
vat_pct = get_vat_pct(customer, team)
item_already_added = False
if not customer_store_order:
# create new order
customer_store_order = Order(key=customer_store_order_key)
customer_store_order.contact_id = contact.key().id()
customer_store_order.date = now()
customer_store_order.vat_pct = 0
customer_store_order.amount = 0
customer_store_order.vat = 0
customer_store_order.vat_pct = vat_pct
customer_store_order.total_amount = 0
customer_store_order.is_subscription_order = False
customer_store_order.manager = STORE_MANAGER
customer_store_order.team_id = None
else:
order_items = OrderItem.list_by_order(customer_store_order.key())
for i in order_items:
number = i.number if i.number > number else number
existing_order_items.append(i)
# Check if this city isn't already in the possible pending order.
if hasattr(i, 'app_id') and (i.app_id == item.app_id or
item.app_id in customer.app_ids):
raise BusinessException(
translate(lang, SOLUTION_COMMON,
u'item_already_added'))
else:
# Check if there already is an orderitem with the same product code.
# If so, add the count of this new item to the existing item.
for it in order_items:
if it.product_code == item.code and it.product_code not in (
Product.PRODUCT_EXTRA_CITY,
Product.PRODUCT_NEWS_PROMOTION):
if (
it.count + item.count
) in product.possible_counts or not product.possible_counts:
it.count += item.count
item_already_added = True
to_put.append(it)
order_item = it
elif len(product.possible_counts) != 0:
raise BusinessException(
translate(
lang,
SOLUTION_COMMON,
u'cant_order_more_than_specified',
allowed_items=max(
product.possible_counts)))
if item.app_id is not MISSING:
remaining_length, _ = get_subscription_order_remaining_length(
customer.id, customer.subscription_order_number)
subscription_order_charge_date = format_date(
datetime.datetime.utcfromtimestamp(sub_order.next_charge_date),
locale=lang)
total = remaining_length * product.price
else:
total = product.price * item.count
vat = total * vat_pct / 100
total_price = total + vat
customer_store_order.amount += total
customer_store_order.vat += vat
azzert(customer_store_order.total_amount >= 0)
customer_store_order.total_amount += total_price
service_visible_in_translation = None
if not item_already_added:
order_item = OrderItem(parent=customer_store_order.key())
order_item.number = number
order_item.comment = product.default_comment(customer.language)
order_item.product_code = product.code
if item.app_id is not MISSING:
order_item.count = remaining_length
service_visible_in_translation = translate(
lang,
SOLUTION_COMMON,
'service_visible_in_app',
subscription_expiration_date=subscription_order_charge_date,
amount_of_months=remaining_length,
extra_city_price=product.price_in_euro,
app_name=app.name)
else:
order_item.count = item.count
order_item.price = product.price
if item.app_id is not MISSING:
order_item.app_id = item.app_id
to_put.append(order_item)
to_put.append(customer_store_order)
db.put(to_put)
return order_item, service_visible_in_translation
