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)