def _9000_reconnect_friends(job_key, initial_run=True):
phase = MigrateServiceJob.PHASE_9000_RECONNECT_FRIENDS
next_phase = MigrateServiceJob.PHASE_DONE
# Validate that the job still exists
job = _get_job(job_key, phase)
# Do the work
if initial_run:
_log_progress(job)
# Schedule breakup
for fsic_str_key in job.fsic_keys:
fsic_key = db.Key(fsic_str_key)
app_user = users.User(fsic_key.parent().name())
old_si_user = users.User(fsic_key.name())
new_si_user = create_service_identity_user(job.to_service_user,
get_identity_from_service_identity_user(old_si_user))
deferred.defer(_make_friends, job_key, app_user, new_si_user, fsic_str_key, _queue=MIGRATION_QUEUE)
else:
# Check the friend count
current_friend_count = get_all_service_friend_keys_query(job.to_service_user).count(limit=None)
expected_friend_count = len(job.fsic_keys)
logging.info('Friend count: %s/%s', current_friend_count, expected_friend_count)
if current_friend_count == expected_friend_count:
# Set the next phase
_set_job_in_next_phase(job_key, phase, next_phase)
return
deferred.defer(_9000_reconnect_friends, job_key, False,
_countdown=5, _queue=HIGH_LOAD_CONTROLLER_QUEUE)
def test_association_creation(self):
self.set_datastore_hr_probability(1)
apps = [a.app_id for a in App.all()]
r = create_flex_service(email=u'*****@*****.**',
name=u"test",
address=u"Antwerpsesteenweg 19\n9080 Lochristi",
phone_number=u"+32 9 324 25 64",
languages=[u"en", u"nl"],
currency=u"€",
modules=[SolutionModule.CITY_APP, SolutionModule.BROADCAST, SolutionModule.ASK_QUESTION,
SolutionModule.WHEN_WHERE],
broadcast_types=['News', 'test'],
apps=apps,
allow_redeploy=False,
organization_type=OrganizationType.CITY)
# Create city customer
shop_user = users.User(u'*****@*****.**')
customer_id = None
vat = u''
name = u'Town Lochristi'
address1 = u'Dorp - West 52'
address2 = u''
zip_code = u'9080'
city = u'Lochristi'
country = u'BE'
language = u'nl'
organization_type = OrganizationType.CITY
prospect_id = None
city_customer = create_or_update_customer(shop_user, customer_id, vat, name, address1, address2, zip_code, city,
country, language, organization_type, prospect_id,
team_id=RegioManagerTeam.all().get().id)
city_customer.service_email = city_customer.user_email = r.login
city_customer.default_app_id = apps[0]
city_customer.app_ids = apps
city_customer.put()
# Create city contact
first_name = u'Firstname'
last_name = u'Lastname'
email_address = u'*****@*****.**'
phone_number = u'+3293268806'
create_contact(city_customer, first_name, last_name, email_address, phone_number)
name = u'test-Test association'
address1 = u'Antwerpsesteenweg 19'
address2 = u''
zip_code = u'9080'
city = u'Lochristi'
user_email = u'*****@*****.**'
telephone = u'+32 9 324 25 64'
language = u'nl'
modules = [u'agenda', u'bulk_invite', u'static_content', u'ask_question', u'broadcast']
broadcast_types = [u'Evenementen', u'Nieuws']
set_current_user(users.User(r.login), set_google_user=False)
output = rest_put_service(name, address1, address2, zip_code, city, user_email, telephone, language, modules,
broadcast_types)
self.assertTrue(output.success, output.errormsg)
self.assertFalse(output.errormsg)
def signup(user, service_name, service_description):
solution_server_settings = get_solution_server_settings()
azzert(users.get_current_user() == users.User(
solution_server_settings.solution_trial_service_email))
user = users.User(user)
from rogerthat.bizz.service.yourservicehere import signup as trial_signup
return trial_signup(user, service_name, service_description, True)
def trans4():
p = get_user_profile(users.User(app_user_email), cached=False)
for old_si_email, service_roles in service_grant_dict.iteritems():
old_si_user = users.User(old_si_email)
new_si_user = create_service_identity_user(job.to_service_user,
get_identity_from_service_identity_user(old_si_user))
for role in service_roles:
logging.debug("Granting role %s to %s for %s", role, app_user_email, new_si_user)
p.grant_role(new_si_user, role)
p.put()
def _change_charges_manager(manager_email, replacement_manager_email):
logging.info('Setting regional manager on charges from %s to %s',
manager_email, replacement_manager_email)
to_put = []
replacement_user = users.User(replacement_manager_email)
charges = Charge.all().filter('manager',
users.User(manager_email)).fetch(None)
for charge in charges:
charge.manager = replacement_user
to_put.append(charge)
put_in_chunks(to_put)
def _change_orders_manager(manager_email, replacement_manager_email):
logging.info('Setting regional manager on orders from %s to %s',
manager_email, replacement_manager_email)
to_put = []
replacement_user = users.User(replacement_manager_email)
orders = Order.all().filter('manager',
users.User(manager_email)).fetch(None)
for order in orders:
order.manager = replacement_user
to_put.append(order)
put_in_chunks(to_put)
def _5000_migrate_non_ancestor_models(job_key):
phase = MigrateServiceJob.PHASE_5000_MIGRATE_NON_ANCESTOR_MODELS
next_phase = MigrateServiceJob.PHASE_6000_MIGRATE_ANCESTOR_MODELS
# Validate that the job still exists
job = _get_job(job_key, phase)
# Do the work
_log_progress(job)
models = list()
logging.debug("1/ Collecting TrialServiceAccounts")
for model in TrialServiceAccount.all().filter("service", job.from_service_user):
model.service = job.to_service_user
models.append(model)
logging.info("2/ Collecting MessageFlowRunRecords")
for model in MessageFlowRunRecord.all().filter("service_identity >=", job.from_service_user.email() + '/').filter("service_identity <", job.from_service_user.email() + u"/\ufffd"):
identity = get_identity_from_service_identity_user(users.User(model.service_identity))
model.service_identity = create_service_identity_user(job.to_service_user, identity).email()
models.append(model)
logging.info("3/ Collecting Avatar, Branding, SIKKey, APIKey")
for model_class in (Avatar, Branding, SIKKey, APIKey):
for model in model_class.all().filter("user", job.from_service_user):
model.user = job.to_service_user
models.append(model)
logging.info('Putting %s non-ancestor models', len(models))
_put_and_invalidate_cache_and_allocate_ids(*models)
# Set the next phase
_set_job_in_next_phase(job_key, phase, next_phase)
def solution_coupon_redeem(service_user, email, method, params, tag,
service_identity, user_details):
data = json.loads(params)
coupon_id = data.get('coupon_id')
redeeming_user = users.User(data.get('redeeming_user'))
response = SendApiCallCallbackResultTO()
lang = get_solution_settings(service_user).main_language
service_identity_user = get_and_validate_service_identity_user(
service_user, service_identity)
try:
coupon = redeem_news_coupon(coupon_id, service_identity_user,
redeeming_user)
with users.set_user(service_user):
news_item = news.get(coupon.news_id, service_identity)
response.result = u'%s' % json.dumps(
serialize_complex_value(news_item, NewsItemTO, False))
except NewsCouponNotFoundException:
response.error = t(lang, 'coupon_not_found')
except NewsCouponAlreadyUsedException:
response.error = t(lang, 'you_have_already_used_this_coupon')
user, app_id = get_app_user_tuple(redeeming_user)
member = BaseMemberTO(user.email(), app_id)
disable_news_with_coupon(coupon_id, service_identity_user, member)
except Exception as exception:
logging.error(exception)
response.error = t(lang, 'error-occured-unknown')
return response
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 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 parse_data(self, email, data):
user = users.User(email)
data = base64.decodestring(data)
data = decrypt(user, data)
data = json.loads(data)
azzert(data["d"] == calculate_secure_url_digest(data))
return data, user
def test_create_service_with_existing_user(self):
self.set_datastore_hr_probability(1)
rogerthat_service_email = "*****@*****.**"
rogerthat_email = "*****@*****.**"
rogerthat_user = create_app_user_by_email(rogerthat_email, 'rogerthat')
be_loc_email = "*****@*****.**"
be_loc_user = create_app_user_by_email(be_loc_email, 'be-loc')
for u in (rogerthat_user, be_loc_user):
create_user_profile(u, u.email())
with self.assertRaises(
UserWithThisEmailAddressAlreadyExistsException) as cm:
create_solution_service(rogerthat_email, 'name', solution='flex')
self.assertEqual(rogerthat_email, cm.exception.fields['email'])
_, new_service_sln_settings = create_solution_service(
rogerthat_service_email,
'name',
solution='flex',
owner_user_email=rogerthat_email)
new_service_user = new_service_sln_settings.service_user
self.assertEqual(rogerthat_service_email, new_service_user.email())
self.assertTrue(rogerthat_service_email in get_user_profile(
users.User(rogerthat_email), cached=False).owningServiceEmails)
_, new_service_sln_settings = create_solution_service(be_loc_email,
'name',
solution='flex')
new_service_user = new_service_sln_settings.service_user
self.assertEqual(be_loc_email, new_service_user.email())
def setUp(self, datastore_hr_probability=0):
mc_unittest.TestCase.setUp(
self, datastore_hr_probability=datastore_hr_probability)
self.current_user = users.User('*****@*****.**')
create_user_profile(self.current_user, u'test', DEFAULT_LANGUAGE)
set_current_user(self.current_user)
def test_static_flex_service(self):
self.set_datastore_hr_probability(1)
print 'Test service creation with static modules'
email = u'test1.flex.foo.com'
r = create_flex_service(email,
name="test",
address="Antwerpsesteenweg 19\n9080 Lochristi",
phone_number="+32 9 324 25 64",
languages=["en", "nl"],
currency=u"€",
modules=list(SolutionModule.STATIC_MODULES),
broadcast_types=['test1', 'test2', 'test3'],
apps=[a.app_id for a in App.all()],
allow_redeploy=False,
organization_type=random.choice([
x for x in OrganizationType.all() if x > 0
]))
service_user = users.User(r.login)
set_current_user(service_user)
print 'Test provisioning of static modules'
common_provision(service_user)
print 'Test rendering the home page'
FlexHomeHandler({}, webapp2.Response()).get()
def get(self):
data_dict, app_user = self.get_user_info()
if not data_dict or not app_user:
language = self.request.get("language", DEFAULT_LANGUAGE)
title = common_translate(language, SOLUTION_COMMON, u'Error')
text = common_translate(language, SOLUTION_COMMON, u"error-occured-unknown-try-again")
else:
azzert(data_dict['a'] == "loyalty_no_mobiles_lottery_winner")
service_email = data_dict['e']
service_identity_user = users.User(service_email)
service_user, service_identity = get_service_identity_tuple(service_identity_user)
user_profile = db.get(UserProfile.createKey(app_user))
if user_profile:
language = self.request.get("language", user_profile.language)
if redeem_lottery_winner(service_user, service_identity, data_dict['mk'], app_user, user_profile.name):
title = common_translate(language, SOLUTION_COMMON, u'Success')
text = common_translate(language, SOLUTION_COMMON, u'loyalty-lottery-loot-receive')
else:
title = common_translate(language, SOLUTION_COMMON, u'Error')
text = common_translate(language, SOLUTION_COMMON, u'Unfortunately you have not confirmed on time and lost your chance')
else:
language = self.request.get("language", DEFAULT_LANGUAGE)
title = common_translate(language, SOLUTION_COMMON, u'Error')
text = common_translate(language, SOLUTION_COMMON, u"error-occured-unknown-try-again")
params = {
'title': title,
'text': text
}
jinja_template = JINJA_ENVIRONMENT.get_template('pages/loyalty_title_text.html')
self.response.out.write(jinja_template.render(params))
def get(self):
solution_server_settings = get_solution_server_settings()
for module_name, service_user in chunks(solution_server_settings.solution_news_scrapers, 2):
try:
module = importlib.import_module("solutions.common.cron.news.%s" % module_name)
getattr(module, 'check_for_news')(users.User(service_user))
except:
pass
def _prepareHumans(self, languages):
human_users = dict([(lang, users.User(u"*****@*****.**" % lang))
for lang in languages])
for lang, human_user in human_users.iteritems():
create_user_profile(human_user, human_user.email(), lang)
return human_users
def create_prospect_from_customer(customer):
azzert(customer.prospect_id is None and customer.service_email)
contact = Contact.get_one(customer.key())
azzert(contact)
si = get_default_service_identity(users.User(customer.service_email))
prospect = Prospect(key_name=str(uuid.uuid4()) + str(uuid.uuid4()))
prospect.name = customer.name
prospect.address = ', '.join(filter(None, [customer.address1 + ((' ' + customer.address2) if customer.address2 else ''),
customer.zip_code,
customer.city,
OFFICIALLY_SUPPORTED_COUNTRIES.get(customer.country, customer.country)]))
prospect.phone = contact.phone_number
prospect.email = contact.email
prospect.type = ['establishment']
if customer.organization_type == OrganizationType.EMERGENCY:
prospect.type.append('health')
prospect.customer_id = customer.id
prospect.status = Prospect.STATUS_CUSTOMER
prospect.app_id = si.app_id
solution_server_settings = get_solution_server_settings()
prospect.add_comment(u'Converted customer to prospect', users.User(solution_server_settings.shop_no_reply_email))
try:
result = geo_code(prospect.address)
except GeoCodeZeroResultsException:
try:
result = geo_code(' '.join(filter(None, [customer.zip_code,
customer.city,
OFFICIALLY_SUPPORTED_COUNTRIES.get(customer.country,
customer.country)])))
except GeoCodeZeroResultsException:
logging.warn('Could not geo_code customer: %s', db.to_dict(customer))
return
prospect.geo_point = db.GeoPt(result['geometry']['location']['lat'],
result['geometry']['location']['lng'])
customer.prospect_id = prospect.id
prospect.customer_id = customer.id
logging.info('Creating prospect: %s', db.to_dict(prospect, dict(prospect_id=prospect.id)))
put_and_invalidate_cache(customer, prospect)
return prospect
def create_or_update_solution_service(
solution,
email,
name,
branding_url,
menu_item_color,
address,
phone_number,
languages,
currency,
redeploy,
organization_type=OrganizationType.PROFIT,
modules=None,
broadcast_types=None,
apps=None,
owner_user_email=None,
search_enabled=False,
qualified_identifier=None,
broadcast_to_users=None):
if not redeploy:
password, sln_settings = \
create_solution_service(email, name, branding_url, menu_item_color, address, phone_number,
solution, languages, currency, organization_type=organization_type, modules=modules,
broadcast_types=broadcast_types, apps=apps, owner_user_email=owner_user_email,
search_enabled=search_enabled)
service_user = sln_settings.service_user
else:
service_user = users.User(email)
sln_settings = update_solution_service(
service_user,
branding_url,
menu_item_color,
solution,
languages,
currency,
modules=modules,
broadcast_types=broadcast_types,
apps=apps,
organization_type=organization_type,
name=name,
address=address,
phone_number=phone_number,
qualified_identifier=qualified_identifier)
password = None
deferred.defer(common_provision,
service_user,
broadcast_to_users=broadcast_to_users,
_transactional=db.is_in_transaction(),
_queue=FAST_QUEUE)
resp = ProvisionResponseTO()
resp.login = email
resp.password = password
resp.auto_login_url = generate_auto_login_url(service_user)
return resp
def trans():
job = db.get(job_key)
for si_email, granted_roles in p.grants.iteritems():
if si_email.startswith(si_user_email + '/'):
si_user = users.User(si_email)
for role in granted_roles:
p.revoke_role(si_user, role)
job.add_service_grant(si_user, p.user, role)
put_and_invalidate_cache(p, job)
def _2000_migrate_user_data(job_key):
phase = MigrateServiceJob.PHASE_2000_MIGRATE_USER_DATA
next_phase = MigrateServiceJob.PHASE_2250_CLEANUP_USER_DATA
# Validate that the job still exists
job = _get_job(job_key, phase)
# Do the work
_log_progress(job)
# Get all the UserData models (possibly contains None)
user_data_keys = list()
for fsic_str_key in job.fsic_keys:
fsic_key = db.Key(fsic_str_key)
app_user = users.User(fsic_key.parent().name())
old_si_user = users.User(fsic_key.name())
user_data_keys.append(UserData.createKey(app_user, old_si_user))
if user_data_keys:
# { app_user : { si_user : user_data } }
job_user_datas = dict()
for chunk in chunks(user_data_keys, 200):
for user_data in db.get(chunk):
if user_data:
app_user_datas = job_user_datas.setdefault(user_data.app_user.email(), dict())
if user_data.data:
app_user_datas[user_data.service_identity_user.email()] = user_data.data
elif user_data.userData:
app_user_datas[user_data.service_identity_user.email()] = json.dumps(
user_data.userData.to_json_dict())
if job_user_datas:
logging.info("Storing job.user_datas: %s", job_user_datas)
def trans_update_user_datas():
job = _get_job(job_key)
job.set_user_datas(job_user_datas)
job.put()
db.run_in_transaction(trans_update_user_datas)
# Set the next phase
_set_job_in_next_phase(job_key, phase, next_phase)
def _2250_cleanup_user_data(job_key):
phase = MigrateServiceJob.PHASE_2250_CLEANUP_USER_DATA
next_phase = MigrateServiceJob.PHASE_2500_MIGRATE_SERVICE_DATA
# Validate that the job still exists
job = _get_job(job_key, phase)
_log_progress(job)
# Do the work
user_data_keys = list()
for fsic_str_key in job.fsic_keys:
fsic_key = db.Key(fsic_str_key)
app_user = users.User(fsic_key.parent().name())
old_si_user = users.User(fsic_key.name())
user_data_keys.append(UserData.createKey(app_user, old_si_user))
db.delete(user_data_keys)
# Set the next phase
_set_job_in_next_phase(job_key, phase, next_phase)
def _change_customers_manager(manager_email):
logging.info(
'Unsetting regional manager on customers with assigned manager \'%s\'',
manager_email)
to_put = []
manager_user = users.User(manager_email)
for customer in Customer.all():
if customer.manager == manager_user:
customer.manager = None
to_put.append(customer)
put_in_chunks(to_put)
def migrate_avatar(sln_settings_key):
service_user = users.User(sln_settings_key.id_or_name())
def trans():
service_profile = get_service_profile(service_user)
if not service_profile:
return
sln_avatar = SolutionAvatar(
key=SolutionAvatar.create_key(service_user))
sln_avatar.picture = get_avatar_by_id(service_profile.avatarId).picture
sln_avatar.put()
run_in_xg_transaction(trans)
def job():
countdown = 0
for old_export in SolutionLoyaltyExport.all():
date_int = old_export.year_month
year = date_int / 100
month = date_int % 100
first_day_of_month = int(time.mktime(date(year, month, day=1).timetuple()))
first_day_of_next_month = int(time.mktime(get_next_month(year, month).timetuple()))
service_user_email = old_export.parent_key().name()
sln_settings = SolutionSettings.get(SolutionSettings.create_key(users.User(service_user_email)))
deferred.defer(create_loyalty_statistics_for_service, sln_settings, first_day_of_month,
first_day_of_next_month, _countdown=countdown)
countdown += 15
def get_services(organization_type, cursor=None, limit=50):
city_service_user = users.get_current_user()
si = system.get_identity()
# get all the services in this city
app_id = si.app_ids[0]
city_customer = get_customer(city_service_user)
azzert(organization_type in city_customer.editable_organization_types)
service_customers_qry = Customer.list_enabled_by_organization_type_in_app(app_id, organization_type)
service_customers_qry.with_cursor(cursor)
service_customers = service_customers_qry.fetch(limit)
new_cursor = unicode(service_customers_qry.cursor())
services = []
statistics = get_services_statistics(app_id)
sln_settings_keys = [SolutionSettings.create_key(city_service_user)]
for customer in service_customers:
if not customer.service_email:
logging.error('Customer %d (%s) has default_app_id, but has no service!', customer.id, customer.name)
elif customer.app_id == app_id:
sln_settings_keys.append(SolutionSettings.create_key(users.User(customer.service_email)))
sln_settings_list = db.get(sln_settings_keys)
city_sln_settings = sln_settings_list.pop(0) # type: SolutionSettings
azzert(city_sln_settings.can_edit_services(city_customer))
city_service_email = city_sln_settings.service_user.email()
for customer in service_customers:
service_email = customer.service_email
# Exclude the city app's own service
if customer.app_id == app_id and service_email != city_service_email:
future_events_count = 0
broadcasts_last_month = 0
static_content_count = 0
last_unanswered_question_timestamp = 0
modules = []
for sln_settings in sln_settings_list:
if sln_settings.key().name() == service_email:
modules = sln_settings.modules
if statistics:
for mail in statistics.customer_emails:
if mail == service_email:
index = statistics.customer_emails.index(mail)
future_events_count = statistics.future_events_count[index]
broadcasts_last_month = statistics.broadcasts_last_month[index]
static_content_count = statistics.static_content_count[index]
last_unanswered_question_timestamp = statistics.last_unanswered_questions_timestamps[index]
statistic = ServiceStatisticTO.create(future_events_count, broadcasts_last_month, static_content_count,
last_unanswered_question_timestamp)
services.append(ServiceListTO(service_email, customer.name, statistic, modules, customer.id))
generated_on = statistics.generated_on if statistics else None
return ServicesTO(sorted(services, key=lambda x: x.name.lower()), generated_on, new_cursor)
def _test_dynamic_flex_service(self, language):
self.set_datastore_hr_probability(1)
print 'Test %s service creation with all modules' % language
email = u'*****@*****.**'
r = create_flex_service(email,
name="test",
address="Antwerpsesteenweg 19\n9080 Lochristi",
phone_number="+32 9 324 25 64",
languages=[language],
currency=u"€",
modules=SolutionModule.visible_modules(),
broadcast_types=['test1', 'test2', 'test3'],
apps=[a.app_id for a in App.all()],
allow_redeploy=False,
organization_type=random.choice([
x for x in OrganizationType.all() if x > 0
]))
service_user = users.User(r.login)
set_current_user(service_user)
print 'Setting order type to advanced'
_put_default_menu(service_user)
sln_settings = get_solution_settings(service_user)
sln_order_settings = SolutionOrderSettings(
key=SolutionOrderSettings.create_key(service_user))
sln_order_settings.text_1 = 'text_1'
sln_order_settings.order_type = SolutionOrderSettings.TYPE_ADVANCED
sln_order_settings.leap_time = 1
sln_order_settings.leap_time_type = 86400
sln_order_settings.put()
SolutionOrderWeekdayTimeframe.create_default_timeframes_if_nessecary(
service_user, sln_settings.solution)
print 'Test provisioning of all modules'
common_provision(service_user)
print 'Test rendering the home page'
FlexHomeHandler({}, webapp2.Response()).get()
print 'Test deletion of all modules'
solution_settings = get_solution_settings(service_user)
solution_settings.modules = []
solution_settings.put()
common_provision(service_user)
print 'Test rendering the home page'
FlexHomeHandler({}, webapp2.Response()).get()
def _test_reserve_table(self, service_user, service_identity, user_details, date, people, name, phone, comment, force=False):
# TODO: race conditions?
status, shift_start = availability_and_shift(service_user, None, user_details, date, people, force)
if status != STATUS_AVAILABLE:
return status
date = datetime.datetime.utcfromtimestamp(date)
rogerthat_user = users.User(user_details[0].email) if user_details else None
reservation = RestaurantReservation(service_user=service_user,
user=rogerthat_user, name=name or "John Doe", phone=phone, date=date,
people=people, comment=comment, shift_start=shift_start,
creation_date=datetime.datetime.now())
reservation.put()
key_ = reservation.key()
return unicode(key_), STATUS_AVAILABLE
def get_user_info(self):
email = self.request.get("email", None)
data = self.request.get("data", None)
if not email or not data:
return None, None
try:
data_dict, _ = self.parse_data(email, data)
except:
logging.warn("Could not decipher url!", exc_info=True)
return None, None
app_user = users.User(email)
return data_dict, app_user
def start_migration_for_solution_services(sln_settings_key):
service_user = users.User(sln_settings_key.id_or_name())
def trans():
mfd_list = [
mfd for mfd in get_message_flow_designs_by_status(
service_user, MessageFlowDesign.STATUS_VALID)
if mfd.xml and not mfd.definition
] # XML-only flows
render_js_for_message_flow_designs(mfd_list, notify_friends=False)
for chunk in chunks(mfd_list, 200):
put_and_invalidate_cache(*chunk)
schedule_update_all_friends_of_service_user(service_user)
run_in_xg_transaction(trans)
