def send_app_broadcast(service_identity_user, app_ids, message, identifier):
si = _validate_app_broadcast(service_identity_user, app_ids, message)
tag = _get_tag(identifier)
for app_id in app_ids:
run_job(_get_app_users, [app_id],
_send_app_broadcast_to_user, [si.user, message, tag])
return tag
def add_auto_connected_services(app_id, services, auto_connect_now=True):
def trans():
app = get_app(app_id)
to_be_put = [app]
si_users = [add_slash_default(users.User(acs.service_identity_email)) for acs in services]
service_identities = get_service_identities_by_service_identity_users(si_users)
for si, acs in zip(service_identities, services):
if not si:
raise ServiceWithEmailDoesNotExistsException(acs.service_identity_email)
if app_id not in si.appIds:
si.appIds.append(app_id)
to_be_put.append(si)
acs.service_identity_email = si.user.email()
app.auto_connected_services.add(acs)
put_and_invalidate_cache(*to_be_put)
xg_on = db.create_transaction_options(xg=True)
db.run_in_transaction_options(xg_on, trans)
if auto_connect_now:
for acs in services:
logging.info("There is a new auto-connected service for %s: %s", app_id, acs.service_identity_email)
run_job(get_user_profile_keys_by_app_id, [app_id],
hookup_with_default_services.run_for_auto_connected_service, [acs, None])
def job(main_services):
"""Set app main service emails.
Args:
main_services (dict): app id to service email mapping
"""
run_job(_get_all_apps, [], _set_main_service_email, [main_services])
def _serialize_and_update_friend_for_service_identity(service_identity_user, clear_broadcast_settings_cache,
get_fsics_query_function, get_fsics_query_function_args,
worker_queue=HIGH_LOAD_WORKER_QUEUE):
helper = FriendHelper.serialize(service_identity_user, FRIEND_TYPE_SERVICE)
run_job(get_fsics_query_function, get_fsics_query_function_args, _update_friend_via_friend_connection,
[helper, clear_broadcast_settings_cache],
worker_queue=worker_queue)
def job(queue=HIGH_LOAD_WORKER_QUEUE):
svc_index = search.Index(name=SERVICE_INDEX)
loc_index = search.Index(name=SERVICE_LOCATION_INDEX)
drop_index(svc_index)
drop_index(loc_index)
run_job(query, [], worker, [], worker_queue=queue)
def _run_update_app_asset(app_id, asset):
"""
Args:
app_id (unicode)
asset (AppAssetTO)
"""
request = UpdateAppAssetRequestTO(asset.kind, asset.url, asset.scale_x)
run_job(_get_profile_keys, [app_id], _update_app_asset_for_user, [request])
def job():
svc_index = search.Index(name=SERVICE_INDEX)
loc_index = search.Index(name=SERVICE_LOCATION_INDEX)
drop_index(svc_index)
drop_index(loc_index)
run_job(query, [], worker, [])
def trans(user):
helper = FriendHelper.serialize(user, friend_type)
if friend_type == FRIEND_TYPE_SERVICE:
user = remove_slash_default(user)
else:
update_friend_service_identity_connections(UserProfile.createKey(user), changed_properties)
run_job(get_friends_friends_maps_keys_query, [user], _update_friend, [helper, clear_broadcast_settings_cache],
worker_queue=worker_queue)
def _run_update_embedded_js_for_all_users(db_keys):
def run():
return db.get(db_keys)
xg_on = db.create_transaction_options(xg=True)
js_embedding_models = db.run_in_transaction_options(xg_on, run)
request = UpdateJSEmbeddingRequestTO.fromDBJSEmbedding(js_embedding_models)
run_job(get_active_mobiles_keys, [], _update_embedded_js_for_user, [request])
def schedule_identity_broadcast_message(service_identity_user, broadcast_type, message, answers, flags, branding, tag,
alert_flags, dismiss_button_ui_flags, min_age=None, max_age=None, gender=None,
attachments=None, app_id=None, timeout=0):
broadcast_guid = unicode(uuid.uuid4())
run_job(get_broadcast_audience_of_service_identity_keys_query,
[service_identity_user, min_age, max_age, gender, app_id, broadcast_type],
_identity_broadcast_message,
[broadcast_type, message, answers, flags, branding, tag, alert_flags, dismiss_button_ui_flags, attachments,
timeout, broadcast_guid])
return broadcast_guid
def set_service_enabled(service_user):
"""
Re-enables the service profile and restores all connected users.
"""
service_profile = get_service_profile(service_user)
service_profile.expiredAt = 0
service_profile.enabled = True
service_profile.put()
run_job(get_all_archived_service_friend_keys_query, [service_user], _unarchive_friend_connection, [])
def send_look_and_feel_updates(look_and_feel):
"""
Args:
look_and_feel (AppLookAndFeel)
"""
logging.debug("send_look_and_feel_updates for %s", look_and_feel.id)
service_roles = []
for role in look_and_feel.roles: # type: LookAndFeelServiceRoles
for role_id in role.role_ids:
service_roles.append(u'%s:%s' % (role.service_email, role_id))
run_job(_get_app_users, [look_and_feel.app_id, service_roles], update_look_and_feel_for_user_profile, [])
def create_matches_for_news_item(news_item, old_group_ids, should_create_notification=False):
logging.debug('debugging_news create_matches_for_news_item %s', news_item.id)
logging.warn('debugging_news old_group_ids: %s' % old_group_ids)
logging.warn('debugging_news new_group_ids: %s' % news_item.group_ids)
for group_id in old_group_ids:
if group_id in news_item.group_ids:
continue
run_job(_qry_by_news_and_group_id, [news_item.id, group_id],
_delete_group_matches_for_news_item_worker, [group_id], worker_queue=NEWS_MATCHING_QUEUE)
for group_id in news_item.group_ids:
run_job(_create_matches_for_news_item_qry, [group_id],
_create_matches_for_news_item_worker, [news_item.id, should_create_notification], worker_queue=NEWS_MATCHING_QUEUE)
def job(app_user):
JobMatchingCriteria.create_key(app_user).delete()
JobMatchingNotifications.create_key(app_user).delete()
run_job(_qry_new_matches, [app_user], _worker_delete, [])
run_job(_qry_history_matches, [app_user], _worker_delete, [])
run_job(_qry_starred_matches, [app_user], _worker_delete, [])
def get(self):
run_job(_get_event_reminder_query, [], _process_event_reminder, [])
def _recurrent_billing():
today = now()
products = Product.get_products_dict()
run_job(_qry, [today], _create_charge, [today, products])
def job():
default_team_id = RegioManagerTeam.get_mobicage().id
run_job(_qry, [], _worker, [default_team_id])
def job_set_default_app_id_on_service_identity():
run_job(_get_service_identity_keys, [], _task_set_default_app_id, [])
def expired_vouchers_reminder():
run_job(city_vouchers_enabled_qry, [], remind_user_with_expired_vouchers,
[today()])
def get(self):
run_job(_get_solution_calendars_to_sync_with_google_query, [],
_process_solution_calendar_sync_google_events, [])
def schedule_service_broadcast(service_user, flow, broadcast_type, tag):
broadcast_guid = unicode(uuid.uuid4())
run_job(get_all_service_friend_keys_query, [service_user], _service_broadcast, [flow, broadcast_type, tag, broadcast_guid])
return broadcast_guid
def job(queue=MIGRATION_QUEUE):
usr_index = search.Index(name=USER_INDEX)
drop_index(usr_index)
run_job(query, [], worker, [queue], worker_queue=queue)
def connect_auto_connected_service(app_id, acs):
# type: (unicode, AutoConnectedService) -> None
helper = FriendHelper.serialize(users.User(acs.service_identity_email), FRIEND_TYPE_SERVICE)
run_job(get_user_profile_keys_by_app_id, [app_id],
hookup_with_default_services.run_for_auto_connected_service, [acs, None, helper])
def provision_all_flex():
# Run this last
# updates branding and all modules
run_job(_get_solution_settings_keys, [],
_provision_without_publish, [],
worker_queue=MIGRATION_QUEUE)
def job():
run_job(_qry, [], _worker, [])
def re_index_all_services():
# Run this first
run_job(_service_identity_query, [],
_service_identity_worker, [],
worker_queue=MIGRATION_QUEUE)
def clear_qr_url_from_menus():
# Run this second
run_job(_get_all_restaurant_menu_keys, [],
_clear_qr_url_menu, [],
worker_queue=MIGRATION_QUEUE)
def add_ids_to_menus():
# Run this second
run_job(_get_all_restaurant_menu_keys, [],
_migrate_menu, [],
worker_queue=MIGRATION_QUEUE)
def get(self):
run_job(_get_event_first_start_date_query, [],
_update_first_start_date, [])
def _break_all_friends(parent_service_user, service_user):
run_job(get_all_service_friend_keys_query, [create_service_identity_user(service_user, ServiceIdentity.DEFAULT)], _break_friends, [])
remove_autoconnected_service(service_user)
def get(self):
run_job(_get_solution_settings_query, [], _publish_events_app_data, [])
def _8000_finish_models(job_key):
phase = MigrateServiceJob.PHASE_8000_FINISH_MODELS
next_phase = MigrateServiceJob.PHASE_9000_RECONNECT_FRIENDS
# Validate that the job still exists
job = _get_job(job_key, phase)
# Do the work
_log_progress(job)
try:
logging.info("1/ re_index all service identities asynchronously")
if not is_trial_service(job.to_service_user):
run_job(get_service_identities_query, [job.to_service_user, True],
_re_index_service_identity, [])
logging.info("2/ set solution and enabled on the new ServiceProfile")
def trans2():
to_service_profile = get_service_profile(job.to_service_user)
to_service_profile.enabled = job.service_enabled
to_service_profile.solution = job.solution
to_service_profile.put()
db.run_in_transaction(trans2)
logging.info("3/ couple the service to the customer")
if job.customer_key:
def trans3():
customer = db.get(job.customer_key)
customer.service_email = job.to_service_user.email()
customer.migration_job = None
customer.put()
deferred.defer(re_index_customer, db.Key(job.customer_key),
_queue=MIGRATION_QUEUE, _transactional=True)
db.run_in_transaction(trans3)
else:
logging.debug('There was no customer')
logging.info("4/ grant service roles")
service_grants = job.get_service_grants() # { app_user : { si_user : [roles] } }
for app_user_email, service_grant_dict in service_grants.iteritems():
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()
db.run_in_transaction(trans4)
logging.debug("5/ finish solution models")
if job.solution:
sln_settings = get_solution_settings(job.to_service_user)
main_branding = get_solution_main_branding(job.to_service_user)
users.set_user(job.to_service_user)
try:
if SolutionModule.LOYALTY in sln_settings.modules:
logging.debug('- Provisioning %s', SolutionModule.LOYALTY)
put_loyalty(sln_settings, None, main_branding, sln_settings.main_language, None)
if SolutionModule.QR_CODES in sln_settings.modules:
logging.debug('- Provisioning %s', SolutionModule.QR_CODES)
put_qr_codes(sln_settings, None, main_branding, sln_settings.main_language, None)
logging.debug('- Creating QR codes for calendar admins')
calendars_to_put = []
for sc in SolutionCalendar.all().ancestor(parent_key(sln_settings.service_user, sln_settings.solution)).filter("deleted =", False):
qr_code = create_calendar_admin_qr_code(sc, main_branding.branding_key, sln_settings.main_language)
sc.connector_qrcode = qr_code.image_uri
calendars_to_put.append(sc)
if calendars_to_put:
db.put(calendars_to_put)
logging.debug('- Creating QR codes for inbox forwarding')
flow_identifier = create_inbox_forwarding_flow(main_branding.branding_key, sln_settings.main_language)
qrcode = create_inbox_forwarding_qr_code(None, flow_identifier)
sln_settings.inbox_connector_qrcode = qrcode.image_uri
if sln_settings.identities:
for service_identity in sln_settings.identities:
qrcode = create_inbox_forwarding_qr_code(service_identity, flow_identifier)
def trans():
sln_i_settings = get_solution_identity_settings(sln_settings.service_user, service_identity)
sln_i_settings.inbox_connector_qrcode = qrcode.image_uri
sln_i_settings.put()
db.run_in_transaction(trans)
put_and_invalidate_cache(sln_settings)
finally:
users.clear_user()
else:
logging.debug("The service was not a solution")
except BusinessException, e:
logging.exception("Caught BusinessException")
azzert(False, "Caught BusinessException: %s" % e)
def get(self):
run_job(_get_cityapps_query, [], _gather_events, [])
def job(cls):
azzert(issubclass(cls, db.Model))
run_job(_qry, [cls], _worker, [], worker_queue=MIGRATION_QUEUE)
def job():
run_job(_all_charges, [], set_invoice_number, [])
def send_update_embedded_app(name):
app_ids = get_apps_that_use_embedded_app(name)
application = get_embedded_application(name)
request = UpdateEmbeddedAppRequestTO.from_dict(application.to_dict())
for app_id in app_ids:
run_job(_get_users_per_app, [app_id], send_update_embedded_app_request_worker, [request])
def job():
run_job(_get_all_scheduled_broadcasts, [], _migrate, [])
def update_all_first_event_epoch_events():
run_job(_get_all_events_query, [], _put_event, [])
def schedule_reminders():
schedule_time = now() + 20 * 60
run_job(schedule_reminders_query, [schedule_time], schedule_reminders_worker, [schedule_time], worker_queue=JOBS_WORKER_QUEUE, controller_queue=JOBS_CONTROLLER_QUEUE)
def _re_index_all_vouchers(app_id, queue=HIGH_LOAD_WORKER_QUEUE):
run_job(_all_vouchers, [app_id], re_index_voucher, [], worker_queue=queue)
def job(app_user):
run_job(_qry_messages, [app_user], _worker_messages, [app_user])
run_job(_qry_chats, [app_user], _worker_chats, [app_user])
def job():
run_job(task_qry, [], update_task, [])
def _app_settings_updated(app_id):
run_job(get_user_profiles_by_app_id, [app_id],
push_app_settings_to_user, [app_id])
def job():
run_job(_get_order_solution_settings, [], _set_deleted_status, [])
def job_set_order_timestamp():
run_job(_get_keys, [], _task, [])
def create_all_exports():
run_job(_qry, [], _worker, [])
def remove_autoconnected_service(service_user):
run_job(_get_all_apps_keys_query, [], _remove_autoconnected_service, [service_user])
def job():
run_job(get_all_solution_settings_keys, [], migrate_avatar, [])
def cleanup_friend_connections(service_user):
run_job(get_all_service_friend_keys_query, [service_user], _archive_friend_connection, [])
def job():
run_job(_qry, [], _worker, [])
def migrate():
run_job(_get_profiles, [], _migrate_profile, [], MODE_BATCH, batch_size=500)
def job():
run_job(get_all_solution_settings_keys, [], _re_provision, [])
def send_update_all_embedded_apps(app_id):
embedded_apps = get_embedded_apps_by_app(app_id)
request = UpdateEmbeddedAppsRequestTO(embedded_apps=[EmbeddedAppTO.from_dict(a.to_dict()) for a in embedded_apps])
run_job(_get_users_per_app, [app_id], send_update_embedded_apps_request_worker,
[request])
def job(default_team_id):
run_job(_all_customers, [],
_add_team_id, [default_team_id])
