def get_customer_subscription_length(customer_id):
customer = Customer.get_by_id(customer_id)
if not customer.subscription_order_number:
raise NoSubscriptionFoundException(customer)
months_till_charge, _ = get_subscription_order_remaining_length(
customer_id, customer.subscription_order_number)
return months_till_charge
def set_service_disabled(customer_or_id, disabled_reason_int):
"""
Disables the customer his service, disconnects all users and sets the service invisible.
Args:
customer_or_id (int, long, Customer): customer or id
disabled_reason_int (int, long): reason why the service has been disabled
Raises:
NoSubscriptionException
BusinessException
"""
if isinstance(customer_or_id, Customer):
customer = customer_or_id
else:
customer = Customer.get_by_id(customer_or_id)
if not customer.service_email:
raise NoSubscriptionException(customer)
if disabled_reason_int not in Customer.DISABLED_REASONS:
raise BusinessException('Invalid disable service reason')
service_user = users.User(customer.service_email)
sln_settings = get_solution_settings(service_user)
customer.default_app_id = None
customer.app_ids = []
customer.service_disabled_at = now()
customer.disabled_reason_int = disabled_reason_int
customer.subscription_cancel_pending_date = 0
sln_settings.search_enabled = False
sln_settings.service_disabled = True
db.put([customer, sln_settings])
rogerthat_set_service_disabled(service_user)
def create_task_if_not_order(customer_id):
customer = Customer.get_by_id(customer_id)
# Check if the customer has linked his credit card after he clicked the 'pay' button
# If he didn't (one hour after the last time he tried to pay), create a new ShopTask to call this customer.
if not customer.stripe_valid and customer.team_id:
if customer.prospect_id:
rmt, prospect = db.get([
RegioManagerTeam.create_key(customer.team_id),
Prospect.create_key(customer.prospect_id)
])
else:
prospect = create_prospect_from_customer(customer)
rmt = RegioManagerTeam.get(
RegioManagerTeam.create_key(customer.team_id))
azzert(rmt.support_manager,
'No support manager found for team %s' % rmt.name)
task = create_task(
prospect_or_key=prospect,
status=ShopTask.STATUS_NEW,
task_type=ShopTask.TYPE_SUPPORT_NEEDED,
address=None,
created_by=STORE_MANAGER.email(),
assignee=rmt.support_manager,
execution_time=today() + 86400 + 11 * 3600, # tomorrow, 11:00,
app_id=prospect.app_id,
comment=u"Customer wanted to pay an order in the customer store, "
"but didn't succeed because he did not link his creditcard.",
notify_by_email=True)
task.put()
def link_stripe_to_customer(customer_id_or_service_email, stripe_token,
stripe_token_created, contact_id):
solution_server_settings = get_solution_server_settings()
stripe.api_key = solution_server_settings.stripe_secret_key
if isinstance(customer_id_or_service_email, unicode):
customer = Customer.get_by_service_email(customer_id_or_service_email)
else:
customer = Customer.get_by_id(customer_id_or_service_email)
# Resellers and their customers should not be able to do this
google_user = gusers.get_current_user()
if not customer.team.legal_entity.is_mobicage:
logging.error(
"user %s tried to access function 'link_stripe_to_customer'",
google_user.email())
raise NoPermissionException()
if google_user:
azzert(user_has_permissions_to_team(google_user, customer.team_id))
if customer.stripe_id:
stripe_customer = stripe.Customer.retrieve(customer.stripe_id)
card = stripe_customer.cards.create(card=stripe_token)
stripe_customer.default_card = card.id
stripe_customer.save()
else:
stripe_customer = stripe.Customer.create(
card=stripe_token,
description=u"%s %s -- %s, %s, %s, %s, %s, %s" %
(customer.id, customer.vat, customer.name, customer.address1,
customer.address2, customer.zip_code, customer.city,
customer.country))
card = stripe_customer.cards.data[0]
try_or_defer(store_stripe_link_to_datastore, customer.key(),
stripe_customer.id, card.id, stripe_token_created, contact_id)
def get(self):
customer_id = int(self.request.get("customer_id"))
try:
customer = Customer.get_by_id(customer_id)
except CustomerNotFoundException:
self.abort(404)
current_user = users.get_current_user()
current_customer = get_customer(current_user)
sln_settings = get_solution_settings(current_user)
if not sln_settings.can_edit_services(
current_customer) or not current_customer.can_edit_service(
customer):
logging.warn(
'Service or user %s is trying to login to the dashboard of %s',
current_user.email(), customer.name)
self.abort(401)
service_identity_user = create_service_identity_user(
users.User(customer.service_email))
current_session = users.get_current_session()
new_secret, new_session = create_session(service_identity_user,
ignore_expiration=True)
set_cookie(self.response,
get_server_settings().cookieSessionName, new_secret)
new_session = switch_to_service_identity(new_session,
service_identity_user,
read_only=False,
shop=current_session.shop,
layout_only=True)
new_session.parent_session_secret = current_session.secret
new_session.put()
self.redirect("/")
def get_subscription_order(customer_id):
customer = Customer.get_by_id(customer_id)
if not customer.subscription_order_number:
raise NoSubscriptionException(customer)
order = Order.get_by_order_number(customer.id,
customer.subscription_order_number)
if not order.status == Order.STATUS_SIGNED:
raise BusinessException(
'The customer his subscription order has not been signed yet.')
return order
def set_next_charge_date(customer_id, next_charge_date):
customer = Customer.get_by_id(customer_id)
if not customer.subscription_order_number:
raise NoSubscriptionException(customer)
order = Order.get_by_order_number(customer_id,
customer.subscription_order_number)
if not order.status == Order.STATUS_SIGNED:
raise BusinessException(
'The customer his subscription order has not been signed yet.')
order.next_charge_date = next_charge_date
order.put()
def customer_get_editable_organization_types(customer_id):
request = GenericRESTRequestHandler.getCurrentRequest()
language = get_languages_from_request(request)[0]
try:
customer = Customer.get_by_id(customer_id)
if not language:
language = customer.language
return dict(get_organization_types(customer, language))
except CustomerNotFoundException:
return {}
def cancel_subscription(customer_id, cancel_reason, immediately=False):
"""
Marks the customer his subscription as disabled.
Recurrent billing will disable the service and disconnect all users after the subscription has ended.
When the 'immediately' parameter is set, the service will be disabled immediately.
Args:
customer_id (int, long): Customer id
cancel_reason (unicode): Reason why the subscription has been canceled.
immediately (bool): Set to True to disable the service immediately
Returns: None
Raises:
EmptyValueException
CustomerNotFoundException
NoSubscriptionException
"""
if not cancel_reason:
raise EmptyValueException('cancel_reason')
customer = Customer.get_by_id(customer_id)
if not customer.subscription_order_number:
raise NoSubscriptionException(customer)
order = Order.get_by_order_number(customer_id,
customer.subscription_order_number)
if immediately or order.status != Order.STATUS_SIGNED:
def trans():
try:
cancel_order(customer, customer.subscription_order_number)
except OrderAlreadyCanceledException as exception:
logging.info('Order %s already canceled, continueing...' %
exception.order.order_number)
customer.disabled_reason = cancel_reason
set_service_disabled(customer, Customer.DISABLED_OTHER)
run_in_xg_transaction(trans)
else:
customer.disabled_reason = cancel_reason
customer.subscription_cancel_pending_date = now()
customer.put()
def set_service_enabled(customer_id):
customer = Customer.get_by_id(customer_id)
if not customer.service_email:
raise NoSubscriptionException(customer)
service_user = users.User(customer.service_email)
service_identity_user = create_service_identity_user(service_user)
si = get_service_identity(service_identity_user)
sln_settings = get_solution_settings(service_user)
sln_settings.service_disabled = False
customer.service_disabled_at = 0
customer.disabled_reason = u''
customer.disabled_reason_int = 0
customer.subscription_cancel_pending_date = 0
# restore app ids
customer.app_ids = si.sorted_app_ids
customer.default_app_id = si.app_id
db.put([customer, sln_settings])
rogerthat_re_enable_service(service_user)
def get(self):
from shop.models import Customer, Invoice
service_user = users.get_current_user()
customer_id = long(self.request.get("customer_id"))
order_number = self.request.get("order_number")
charge_id = long(self.request.get("charge_id"))
invoice_number = self.request.get("invoice_number")
download = self.request.get("download", "false") == "true"
self.response.headers['Content-Type'] = 'application/pdf'
self.response.headers['Content-Disposition'] = str(
'%s; filename=invoice_%s.pdf' %
("attachment" if download else "inline", invoice_number))
try:
customer = Customer.get_by_id(customer_id)
except CustomerNotFoundException, exception:
logging.exception(exception)
self.abort(500)
return
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 trans():
from_profile = _get_profile_not_cached(from_user)
if from_profile:
bizz_check(
isinstance(from_profile, UserProfile),
'Profile %s is not of expected type UserProfile, but of type %s'
% (from_user, from_profile.kind()))
else:
logging.warn('UserProfile for %s not found! Weird...',
from_user.email())
to_put = set()
to_profile = _get_profile_not_cached(to_user)
if to_profile:
bizz_check(
isinstance(to_profile, UserProfile),
'Profile %s is not of expected type UserProfile, but of type %s'
% (to_user, to_profile.kind()))
if service_email not in to_profile.owningServiceEmails:
to_profile.owningServiceEmails.append(service_email)
to_put.add(to_profile)
else:
if from_profile:
language = from_profile.language
password_hash = from_profile.passwordHash
else:
service_profile = get_service_profile(
users.User(service_email))
language = service_profile.defaultLanguage
password_hash = service_profile.passwordHash
to_profile = create_user_profile(to_user, to_user.email(),
language)
to_profile.isCreatedForService = True
to_profile.owningServiceEmails = [service_email]
update_password_hash(to_profile, password_hash, now())
if from_profile:
if service_email in from_profile.owningServiceEmails:
from_profile.owningServiceEmails.remove(service_email)
to_put.add(from_profile)
if not from_profile.owningServiceEmails:
@db.non_transactional
def has_mobiles():
return bool(
list(get_user_active_mobiles(from_profile.user)))
if has_mobiles():
from_profile.isCreatedForService = False
to_put.add(from_profile)
else:
delete_account(from_user)
si = get_default_service_identity_not_cached(users.User(service_email))
si.qualifiedIdentifier = to_user.email()
to_put.add(si)
sln_settings = get_solution_settings(users.User(service_email))
sln_settings.login = to_user
sln_settings.qualified_identifier = to_user.email()
to_put.add(sln_settings)
if customer_id is not None:
customer = Customer.get_by_id(customer_id)
customer.user_email = to_user.email()
to_put.add(customer)
put_and_invalidate_cache(*to_put)
def rest_put_service(name, address1, address2, zip_code, city, user_email, telephone, language, modules,
broadcast_types, customer_id=None, organization_type=OrganizationType.PROFIT, vat=None,
website=None, facebook_page=None, force=False):
city_service_user = users.get_current_user()
city_customer = get_customer(city_service_user)
city_sln_settings = get_solution_settings(city_service_user)
lang = city_sln_settings.main_language
customer = Customer.get_by_id(customer_id) if customer_id else None
# check if the current user is in fact a city app
if customer and not city_customer.can_edit_service(customer):
logging.warn(u'Service %s tried to save service information for customer %d', city_service_user, customer.id)
return CreateServiceStatusTO.create(False, translate(lang, SOLUTION_COMMON, 'no_permission'))
error_msg = warning_msg = None
email_changed = False
is_new_service = False
try:
modules = filter_modules(city_customer, modules, broadcast_types)
service = create_customer_service_to(name, address1, address2, city, zip_code, user_email, language, city_sln_settings.currency,
telephone, organization_type, city_customer.app_id, broadcast_types, modules)
(customer, email_changed, is_new_service) \
= create_customer_with_service(city_customer, customer, service, name, address1, address2, zip_code, city,
language, organization_type, vat, website, facebook_page, force=force)
except EmptyValueException as ex:
val_name = translate(lang, SOLUTION_COMMON, ex.value_name)
error_msg = translate(lang, SOLUTION_COMMON, 'empty_field_error', field_name=val_name)
except ServiceNameTooBigException:
error_msg = translate(lang, SOLUTION_COMMON, 'name_cannot_be_bigger_than_n_characters', n=50)
except DuplicateCustomerNameException as ex:
warning_msg = translate(lang, SOLUTION_COMMON, 'duplicate_customer', customer_name=ex.name)
except NoPermissionException:
error_msg = translate(lang, SOLUTION_COMMON, 'no_permission')
except InvalidEmailFormatException as ex:
error_msg = translate(lang, SOLUTION_COMMON, 'invalid_email_format', email=ex.email)
except NotOperatingInCountryException as ex:
error_msg = translate(lang, SOLUTION_COMMON, 'not_operating_in_country', country=ex.country)
except BusinessException as ex:
logging.debug('Failed to create service, BusinessException', exc_info=True)
error_msg = ex.message
except:
logging.exception('Failed to create service')
error_msg = translate(lang, SOLUTION_COMMON, 'failed_to_create_service')
finally:
if error_msg:
return CreateServiceStatusTO.create(False, error_msg)
elif warning_msg:
return CreateServiceStatusTO.create(False, warningmsg=warning_msg)
try:
put_customer_service(customer, service, skip_module_check=True, search_enabled=False,
skip_email_check=True, rollback=is_new_service)
except EmptyValueException as ex:
val_name = translate(lang, SOLUTION_COMMON, ex.value_name)
error_msg = translate(lang, SOLUTION_COMMON, 'empty_field_error', field_name=val_name)
except:
logging.exception('Could not save service service information')
error_msg = translate(lang, SOLUTION_COMMON, 'failed_to_create_service')
finally:
if error_msg:
if is_new_service:
logging.warn('Failed to save new service service information, changes would be reverted...')
return CreateServiceStatusTO.create(False, error_msg)
else:
if email_changed:
migrate_user(users.User(customer.user_email), users.User(customer.user_email), users.User(user_email),
customer.service_email)
customer.user_email = user_email
customer.put()
variables = dict_str_for_audit_log({
'user_email': user_email,
'modules': modules,
})
audit_log(customer_id, 'put_service', variables, city_service_user)
return CreateServiceStatusTO.create()