def rest_get_news_promoted_count(app_ids): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity if is_default_service_identity(service_identity): service_identity_user = create_service_identity_user(service_user) else: service_identity_user = create_service_identity_user( service_user, service_identity) return get_sponsored_news_count(service_identity_user, app_ids)
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 solution_remind_event(service_user, email, method, params, tag, service_identity, user_details): settings = get_solution_settings(service_user) jsondata = json.loads(params) app_user = create_app_user_by_email(email, user_details[0].app_id) event_id = long(jsondata['eventId']) remind_before = int(jsondata['remindBefore']) if jsondata.get("eventStartEpoch", None): event_start_epoch = int(jsondata['eventStartEpoch']) else: event_start_epoch = get_event_by_id(service_user, settings.solution, event_id).start_dates[0] r = SendApiCallCallbackResultTO() if is_reminder_set(app_user, event_id, event_start_epoch, remind_before) is False: er = EventReminder() er.service_identity_user = create_service_identity_user( users.get_current_user(), service_identity) er.human_user = app_user er.remind_before = remind_before er.event_id = event_id er.event_start_epoch = event_start_epoch er.put() r.result = u"successfully reminded" else: r.result = u"already reminded" r.error = None return r
def trans(): to_put = list() service_profile = get_service_profile(service_user) service_profile.expiredAt = now() service_profile.enabled = False to_put.append(service_profile) service_identity_keys = get_service_identities_query(service_user, True) search_configs = db.get( [SearchConfig.create_key(create_service_identity_user(users.User(key.parent().name()), key.name())) for key in service_identity_keys]) svc_index = search.Index(name=SERVICE_INDEX) loc_index = search.Index(name=SERVICE_LOCATION_INDEX) for search_config in search_configs: if search_config: search_config.enabled = False to_put.append(search_config) on_trans_committed(_cleanup_search_index, search_config.service_identity_user.email(), svc_index, loc_index) for objects_to_put in chunks(to_put, 200): put_and_invalidate_cache(*objects_to_put) deferred.defer(cleanup_sessions, service_user, _transactional=True) deferred.defer(cleanup_friend_connections, service_user, _transactional=True)
def trans_create(avatar, image, share_sid_key): azzert(not get_service_profile(service_user, cached=False)) azzert(not get_default_service_identity_not_cached(service_user)) profile = ServiceProfile(parent=parent_key(service_user), key_name=service_user.email()) profile.avatarId = avatar.key().id() _calculateAndSetAvatarHash(profile, image) service_identity_user = create_service_identity_user(service_user, ServiceIdentity.DEFAULT) service_identity = ServiceIdentity(key=ServiceIdentity.keyFromUser(service_identity_user)) service_identity.inheritanceFlags = 0 service_identity.name = name service_identity.description = "%s (%s)" % (name, service_user.email()) service_identity.shareSIDKey = share_sid_key service_identity.shareEnabled = False service_identity.creationTimestamp = now() service_identity.appIds = supported_app_ids update_result = update_func(profile, service_identity) if update_func else None put_and_invalidate_cache(profile, service_identity, ProfilePointer.create(service_user), ProfileHashIndex.create(service_user)) deferred.defer(create_default_qr_templates, service_user, _transactional=True) return profile, service_identity, update_result
def post(self): uuid = self.request.get('uuid') major = self.request.get('major') minor = self.request.get('minor') tag = self.request.get('tag') service = self.request.get('service') identity = self.request.get('identity') if not (uuid and major and minor and service and identity): return self.redirect(result='Please supply all parameters.') logging.info("New beacon added uuid: %s major: %s minor: %s for: %s/%s" % (uuid, major, minor, service, identity)) try: service_user = users.User(service) service_identity_user = create_service_identity_user(service_user, identity) si = get_service_identity(service_identity_user) if not si: self.redirect(result='Service not found.') return name = "%s|%s" % (major, minor) added = add_new_beacon(uuid, name, tag, service_identity_user) if added: self.redirect(result='Added beacon with name: %s for: %s' % (name, service_identity_user)) else: self.redirect(result='Beacon already exists: %s for: %s' % (name, service_identity_user)) except Exception, e: logging.warn(str(e), exc_info=1) self.redirect(result=str(e))
def _build_job(job_guid, cursor): job = db.get(RebuildRolesJob.create_key(job_guid)) start = time.time() qry = get_all_service_friend_keys_query(create_service_identity_user(job.service_user)) while True: qry.with_cursor(cursor) fsic_keys = qry.fetch(100) cursor = qry.cursor() logging.debug("Fetched %s FriendServiceIdentityConnection keys", len(fsic_keys)) if not fsic_keys: # Query reached its end deferred.defer(_start_job, job_guid, _queue=HIGH_LOAD_CONTROLLER_QUEUE) return work = list() for fsic_key in fsic_keys: app_user = users.User(fsic_key.parent().name()) if job.app_users and not app_user in job.app_users: continue service_identity_user = users.User(fsic_key.name()) if job.service_identity_users and not service_identity_user in job.service_identity_users: continue work.append(RebuildRolesJobMember( key=RebuildRolesJobMember.create_key(job, app_user, service_identity_user))) db.put(work) if time.time() - start > 500: deferred.defer(_build_job, job_guid, cursor, _queue=HIGH_LOAD_CONTROLLER_QUEUE) return
def get_service_identity_details(identifier): azzert(identifier) service_user = users.get_current_user() service_identity_user = create_service_identity_user(service_user, identifier) service_identity = get_service_identity_not_cached(service_identity_user) service_profile = get_service_profile(service_user, cached=False) return ServiceIdentityDetailsTO.fromServiceIdentity(service_identity, service_profile)
def new_inbox_message(sln_settings, message, parent_chat_key=None, service_identity=None, **kwargs): service_identity = service_identity or ServiceIdentity.DEFAULT service_user = sln_settings.service_user language = sln_settings.main_language si = get_service_identity( create_service_identity_user(service_user, service_identity)) user_details = UserDetailsTO.create(service_user.email(), si.name, language, si.avatarUrl, si.app_id) if not parent_chat_key: category = kwargs.get('category') category_key = kwargs.get('category_key') reply_enabled = kwargs.get('reply_enabled', False) message = create_solution_inbox_message(service_user, service_identity, category, category_key, True, [user_details], now(), message, reply_enabled) else: message, _ = add_solution_inbox_message(service_user, parent_chat_key, False, [user_details], now(), message, **kwargs) return message
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 has_role(service_identity, user, role): if isinstance(service_identity, users.User): service_identity_user = service_identity service_identity = get_service_identity(service_identity_user) azzert(service_identity, "Service identity %s not found" % service_identity_user) else: service_identity_user = service_identity.service_identity_user if isinstance(user, users.User): user_profile = get_user_profile(user, True) else: user_profile = user user = user_profile.user if isinstance(role, unicode): # Admin role, just fallback on UserProfile.has_role return user_profile.has_role(service_identity_user, role) azzert(role.service_user == service_identity.service_user) role = u'sr:%s' % role.role_id # check on the service identity itself if user_profile.has_role(service_identity_user, role): return True if service_identity.is_default: return False # check on the default service identity return user_profile.has_role(create_service_identity_user(service_identity.service_user, ServiceIdentity.DEFAULT), role)
def get(self): service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity slide_id = self.request.get('i') if not slide_id: self.redirect("/ourcityapp") return slide_id = long(slide_id) if is_default_service_identity(service_identity): service_identity_user = service_user else: service_identity_user = create_service_identity_user(service_user, service_identity) def trans(): slide = SolutionLoyaltySlide.get_by_id(slide_id, parent=parent_key_unsafe(service_identity_user, SOLUTION_COMMON)) return slide slide = db.run_in_transaction(trans) if not slide: self.redirect("/ourcityapp") return server_settings = get_server_settings() jinja_template = JINJA_ENVIRONMENT.get_template('loyalty_preview.html') self.response.out.write(jinja_template.render({'slide_id': slide_id, 'full_url': slide.slide_url(), 'overlay_url': '%s/common/loyalty/slide/overlay' % (server_settings.baseUrl)}))
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 _make_friends(job_key, app_user, si_user, fsic_str_key=None): profile_info = get_profile_info(app_user) if not isinstance(profile_info, UserProfile): logging.warn("%s was no UserProfile but %s", app_user.email(), profile_info) def trans(): job = db.get(job_key) job.fsic_keys.remove(fsic_str_key) job.put() db.run_in_transaction(trans) return user_data_str = None job = db.get(job_key) if job: user_datas = job.get_user_datas() # { app_user : { si_user : user_data } } user_datas_for_app_user = user_datas.get(app_user.email()) if user_datas_for_app_user is not None: old_si_user = create_service_identity_user(job.from_service_user, get_identity_from_service_identity_user(si_user)) user_data_str = user_datas_for_app_user.get(old_si_user.email()) makeFriends(si_user, app_user, original_invitee=None, servicetag=None, origin=None, notify_invitee=False, notify_invitor=False, user_data=user_data_str)
def delete_service_role(service_user, role_id, cleanup_members=False): service_role = get_service_role_by_id(service_user, role_id) if not service_role: raise RoleNotFoundException(role_id) if bool(ServiceMenuDef.all().ancestor(parent_key(service_user)).filter('roles =', role_id).count(1)): raise DeleteRoleFailedHasSMDException(role_id) if cleanup_members: service_identity_user = create_service_identity_user(service_user) role = u'%s' % role_id for srg in get_service_role_grants(service_user, role_id): app_user = create_app_user_by_email(srg.user_email, srg.app_id) def trans(): user_profile = get_user_profile(app_user, False) user_profile.revoke_role(service_identity_user, role) user_profile.put() if db.is_in_transaction(): trans() else: db.run_in_transaction(trans) else: has_grants = any(get_service_role_grants(service_user, role_id)) if has_grants: raise DeleteRoleFailedHasMembersException(role_id) db.delete(service_role) _send_service_role_updates(service_user)
def get_menu(identifier): service_user = users.get_current_user() service_identity_user = create_service_identity_user(service_user, identifier) service_identity = get_service_identity(service_identity_user) dummy_translator = DummyTranslator(get_service_profile(service_user).defaultLanguage) sm = WebServiceMenuTO.fromServiceIdentity(service_identity, dummy_translator.default_language, dummy_translator) return sm
def _handle_service_interaction_based_invitation(self, entry_point, code, language, su, user_agent, version): match = re.match("^/q/s/(.+)/(\\d+)$", su.full) if not match: self.response.out.write(_TMPL % su.full) else: user_code = match.group(1) service_profile = get_service_profile_via_user_code(user_code) if not service_profile: # Profile of usercode not found. Sorry we can't help you :( logging.info("Profile of usercode not found. Sorry we can't help you :(") self.response.out.write(_TMPL % "/") return service_user = service_profile.user if entry_point == "S": # It's a QR-Code logging.info("It's a QR-Code") sid = int(match.group(2)) service_interaction_def = get_service_interaction_def(service_user, int(sid)) service_identity_user = create_service_identity_user(service_user, service_interaction_def.service_identity) service_identity = get_service_identity(service_identity_user) self._handle_after_qr_code_scan(user_agent, service_identity, language, sid) return if entry_point == "M": logging.info("It's a Message") else: logging.warn("Expected entry_point 'M' but got '%s'." % entry_point) # Get service identity by sid sid = int(match.group(2)) service_interaction_def = get_service_interaction_def(service_user, int(sid)) service_identity_user = create_service_identity_user(service_user, service_interaction_def.service_identity) service_identity = get_service_identity(service_identity_user) supported_platform = determine_if_platform_supports_rogerthat_by_user_agent(user_agent) if (version and version == "web") or not supported_platform: logging.info("Unsupported platform ===> Show sorry page with install instructions for android & iphone") variables = {'profile': service_identity, 'payload': urllib.urlencode([("chl", "%s/S/%s" % (get_server_settings().baseUrl, code))]), 'app_name': get_app_name_by_id(service_identity.app_id)} # Unsupported platform ===> Show sorry page with install instructions for android & iphone self.response.out.write(render('sorry_step2', language, variables, 'web')) else: fallback_url = "%s/%s/%s?v=web" % (get_server_settings().baseUrl, entry_point, code) redirect_to_app(self, user_agent.lower(), service_identity.app_id, su.full, fallback_url)
def _set_content_branding(sln_settings): users.set_user(sln_settings.service_user) try: sln_main_branding = get_solution_main_branding(sln_settings.service_user) populate_identity(sln_settings, sln_main_branding.branding_key) identities = [None] if sln_settings.identities: identities.extend(sln_settings.identities) for service_identity in identities: if is_default_service_identity(service_identity): service_identity_user = create_service_identity_user(sln_settings.service_user) else: service_identity_user = create_service_identity_user(sln_settings.service_user, service_identity) deferred.defer(_update_tablets, service_identity_user, None, _queue=HIGH_LOAD_CONTROLLER_QUEUE) finally: users.clear_user()
def search_users(term, app_id=None, admin=False): from rogerthat.bizz.profile import search_users_via_name_or_email service_user = users.get_current_user() default_service_identity_user = create_service_identity_user(service_user, ServiceIdentity.DEFAULT) if not admin and app_id is not None: validate_app_id_for_service_identity_user(default_service_identity_user, app_id) return sorted(search_users_via_name_or_email(term, app_id), key=lambda x: (x.app_id, x.name.upper()))
def revoke_service_role(service_user, identity, user, role_id): service_role = get_service_role_by_id(service_user, role_id) if not service_role: raise RoleNotFoundException(role_id) service_identity_user = create_service_identity_user(service_user, identity) revoke_role(service_identity_user, user, service_role) _send_service_role_grants_updates(service_user) _send_update_friend(service_user, identity, user, force=True)
def grant_service_roles(service_user, identity, user, role_ids): service_roles = get_service_roles_by_ids(service_user, role_ids) for role_id, service_role in zip(role_ids, service_roles): if not service_role: raise RoleNotFoundException(role_id) service_identity_user = create_service_identity_user(service_user, identity) grant_roles(service_identity_user, user, service_roles) _send_service_role_grants_updates(service_user) _send_update_friend(service_user, identity, user, force=True)
def grant_admin_role(user_email, role, identity): service_user = users.get_current_user() service_identity_user = create_service_identity_user(service_user, identity) from rogerthat.bizz.roles import grant_role as grant_role_bizz try: grant_role_bizz(service_identity_user, users.User(user_email), role) return RETURNSTATUS_TO_SUCCESS except BusinessException, e: return ReturnStatusTO.create(False, e.message)
def get_users(service_identity, cursor): service_user = users.get_current_user() service_identity_user = create_service_identity_user(service_user, service_identity) fsics, cursor = get_users_connected_to_service_identity(service_identity_user, cursor) result = GetServiceUsersResponseTO() result.users = [ServiceUserTO.fromFriendServiceIdentityConnection(fsic) for fsic in fsics] result.cursor = unicode(cursor) return result
def _run_update_all_friends_of_service_user(service_user, clear_broadcast_settings_cache, worker_queue=HIGH_LOAD_WORKER_QUEUE): should_clear = db.run_in_transaction(_should_clear_broadcast_settings_flag, service_user, clear_broadcast_settings_cache) for si_key in get_service_identities_query(service_user, keys_only=True): si_user = create_service_identity_user(users.User(si_key.parent().name()), si_key.name()) deferred.defer(_run_update_friends_by_profile_info, si_user, FRIEND_TYPE_SERVICE, None, worker_queue, should_clear or clear_broadcast_settings_cache, _queue=worker_queue)
def _friend_trial_service(user, service): logging.info("Hooking up %s with %s" % (user, service)) service_identity_user = create_service_identity_user(service, ServiceIdentity.DEFAULT) def trans(): makeFriends(service_identity_user, user, user, None, notify_invitee=True, origin=ORIGIN_USER_INVITE) grant_role(service_identity_user, user, roles.ROLE_ADMIN) xg_on = db.create_transaction_options(xg=True) db.run_in_transaction_options(xg_on, trans)
def _send_update_friend(service_user, identity, user, force=False): if identity == ServiceIdentity.DEFAULT: # schedule update for all identities from rogerthat.bizz.job.update_friends import schedule_update_a_friend_of_service_user schedule_update_a_friend_of_service_user(service_user, user, force=force) else: from rogerthat.bizz.job.update_friends import schedule_update_a_friend_of_a_service_identity_user schedule_update_a_friend_of_a_service_identity_user(create_service_identity_user(service_user, identity), user, force=force)
def _run_update_friend_for_service_identities(service_user, clear_broadcast_settings_cache, target_user, worker_queue=HIGH_LOAD_WORKER_QUEUE): should_clear = db.run_in_transaction(_should_clear_broadcast_settings_flag, service_user, clear_broadcast_settings_cache) for si_key in get_service_identities_query(service_user, keys_only=True): si_user = create_service_identity_user(users.User(si_key.parent().name()), si_key.name()) deferred.defer(_serialize_and_update_friend_for_service_identity, si_user, should_clear, get_one_friend_service_identity_connection_keys_query, [si_user, target_user], worker_queue=worker_queue)
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 rm_broadcast_test_person(email, app_id=None): from rogerthat.bizz.service.broadcast import delete_broadcast_test_person service_user = users.get_current_user() default_service_identity_user = create_service_identity_user(service_user, ServiceIdentity.DEFAULT) app_id = get_and_validate_app_id_for_service_identity_user(default_service_identity_user, app_id, email) try: delete_broadcast_test_person(users.get_current_user(), create_app_user(users.User(email), app_id)) return RETURNSTATUS_TO_SUCCESS except BusinessException, be: return ReturnStatusTO.create(False, be.message)
def search_connected_users(name_or_email_term, app_id=None, service_identity=None): from rogerthat.bizz.profile import search_users_via_friend_connection_and_name_or_email service_user = users.get_current_user() if service_identity is None: service_identity = ServiceIdentity.DEFAULT service_identity_user = create_service_identity_user(service_user, service_identity) if app_id is not None: validate_app_id_for_service_identity_user(service_identity_user, app_id) return search_users_via_friend_connection_and_name_or_email(service_user.email() if service_identity is None else service_identity_user.email(), name_or_email_term, app_id)
def _delete_roles(parent_service_user, service_user): for gto in get_service_grants(service_user): if gto.role_type == roles.ROLE_TYPE_ADMIN and gto.role == roles.ROLE_ADMIN and gto.identity == ServiceIdentity.DEFAULT: revoke_role(create_service_identity_user(service_user, gto.identity), create_app_user(users.User(gto.user_email), gto.app_id), gto.role) else: azzert(False, "This should not happen.") deferred.defer(_delete_non_ancestor_models, parent_service_user, service_user) deferred.defer(_delete_ownership_users, service_user.email())
def test_user_data(self): service_user = self._prepare_svc() friend_email = u"*****@*****.**" % time.time() data = json.dumps(dict(test="hihihi")).decode('utf8') self.assertRaises(FriendNotFoundException, put_user_data, friend_email, data) # non-existing user human_user = users.User(friend_email) create_user_profile(human_user, friend_email, language=u'nl') self.assertRaises(FriendNotFoundException, put_user_data, friend_email, data) # user is no friend makeFriends(human_user, service_user, None, None, None) data = json.dumps(dict(test="ikkel", moe="hahaha")).decode('utf8') put_user_data(friend_email, data) data = json.dumps(dict(test="tikkel", john="doe")).decode('utf8') put_user_data(friend_email, data) get_helper = lambda: FriendHelper.from_data_store(service_user, FRIEND_TYPE_SERVICE) get_friendto = lambda: run_in_xg_transaction(lambda: FriendTO.fromDBFriendMap(get_helper(), get_friends_map(human_user), service_user, True, True, human_user)) ud = db.get(UserData.createKey(human_user, create_service_identity_user(service_user))) ud_dict = ud.userData.to_json_dict() ud_dict['__rt__disabledBroadcastTypes'] = ud_dict.get('__rt__disabledBroadcastTypes', []) self.assertDictEqual(dict(test="tikkel", moe="hahaha", john="doe", __rt__disabledBroadcastTypes=[]), ud_dict) self.assertTrue(get_friendto().hasUserData) self.assertRaises(InvalidJsonStringException, put_user_data, friend_email, "invalid user data") self.assertRaises(InvalidJsonStringException, put_user_data, friend_email, "") del_user_data(friend_email, ["test"]) self.assertTrue(get_friendto().hasUserData) del_user_data(friend_email, ["moe", "john"]) self.assertFalse(get_friendto().hasUserData) japanese = u"スキーに行くのが好きです。" data_dict = dict(test="ikkel", moe="hahaha", japanese=japanese) data = json.dumps(data_dict).decode('utf8') put_user_data(friend_email, data) data = json.loads(get_user_data(friend_email, ["japanese"])) self.assertEqual(japanese, data["japanese"]) data = json.loads(get_user_data(friend_email, ["japanese", "test", "moe"])) self.assertDictEqual(data, data_dict)
def test_message_flow(message_flow_design_name, member, force_language=None, app_id=None): from rogerthat.bizz.service.mfr import start_flow, MessageFlowNotValidException, NonFriendMembersException service_user = users.get_current_user() default_service_identity_user = create_service_identity_user(service_user, ServiceIdentity.DEFAULT) app_id = get_and_validate_app_id_for_service_identity_user(default_service_identity_user, app_id, member) app_user = create_app_user(users.User(member), app_id) try: start_flow(default_service_identity_user, None, unicode(get_service_message_flow_design_key_by_name(service_user, message_flow_design_name)), [app_user], True, False, force_language=force_language) except MessageFlowNotValidException, e: return "Message flow could not be started!\n%s" % (e.fields['error'] or '')
def get(self): identifier = self.request.GET.get('identifier') azzert(identifier) cursor = self.request.GET.get('cursor') si = get_service_identity(create_service_identity_user(users.get_current_user(), identifier)) params = {'service_identity': identifier, 'service_identity_name': si.name, 'container_id': 'serviceUsersContainer_%s' % md5_hex(identifier), 'cursor': cursor} self.response.out.write(render('service_users', [DEFAULT_LANGUAGE], params, 'web'))
def get_default_app_id(self, user_hash, identity): index = ProfileHashIndex.get(ProfileHashIndex.create_key(user_hash)) if not index: logging.debug('No profile found with user_hash %s', user_hash) return None si_user = create_service_identity_user(index.user, identity) si = get_service_identity(si_user) if not si: logging.debug('Service identity not found: %s', si_user.email()) return None return si.app_id
def breakFriendship(friend, service_identity=None, app_id=None): # service_identity & app_id are set when a service does a breakFriendship from rogerthat.bizz.friends import breakFriendShip as bizzBreakFriendship user = users.get_current_user() if service_identity and service_identity != MISSING: user = create_service_identity_user(user, service_identity) friend_user = users.User(friend) if app_id: friend_user = create_app_user(friend_user, app_id) else: pass # the bizz layer will handle the app_id stuff return bizzBreakFriendship(user, friend_user)
def get_app_statistics(service_identity): service_user = users.get_current_user() if not service_identity or service_identity == MISSING: service_identity = ServiceIdentity.DEFAULT service_identity_user = create_service_identity_user(service_user, service_identity) si = get_service_identity(service_identity_user) default_app = get_app(si.defaultAppId) customer = get_customer(service_user) available_apps = [a.app_id for a in get_available_apps_for_customer(customer, default_app.demo)] if not available_apps: # Customer does not exist or has no app ids available_apps = sorted(si.appIds) return app.get_app_statistics(available_apps)
def get_target_info(app_user, provider_id, target, currency): target_user = users.User(target) if '/' not in target: target_service_user = create_service_identity_user(target_user) else: target_service_user = target_user target_info_service = _get_target_info_service(target_service_user, provider_id, currency) if target_info_service: return target_info_service if ':' not in target: target_user = create_app_user_by_email(target, get_app_id_from_app_user(app_user)) return _get_target_info_user(target_user, provider_id, currency)
def _create_news_item(message, service_identity, service_user, broadcast_type, urls=None): if service_identity: service_identity_user = create_service_identity_user( service_user, service_identity) si = get_service_identity(service_identity_user) else: si = get_default_service_identity(service_user) service_identity_user = si.service_identity_user if '\n' in message: split = message.splitlines() title = limit_string(split[0], NewsItem.MAX_TITLE_LENGTH) message = '\n'.join(split[1:]) else: title = limit_string(message, NewsItem.MAX_TITLE_LENGTH) news_buttons = [] if urls: for url in urls: if url.get('url') and url.get('name'): id_ = u'url' caption = u'%s' % url['name'] action = u'%s' % url['url'] if len(caption) > NewsItem.MAX_BUTTON_CAPTION_LENGTH: sln_settings = get_solution_settings(service_user) caption = translate(sln_settings.main_language, SOLUTION_COMMON, u'read_more') news_buttons.append(NewsActionButtonTO(id_, caption, action)) break app_ids = [ app_id for app_id in si.appIds if app_id != App.APP_ID_OSA_LOYALTY ] return put_news(service_identity_user, sticky=False, sticky_until=0, title=title, message=message, image=None, news_type=NewsItem.TYPE_NORMAL, broadcast_type=broadcast_type, news_buttons=news_buttons, qr_code_content=None, qr_code_caption=None, app_ids=app_ids, news_id=None, accept_missing=True)
def add_broadcast_test_person(email, app_id=None): from rogerthat.bizz.service.broadcast import add_broadcast_test_person as bizz_add_broadcast_test_person r = BroadcastTestPersonReturnStatusTO() service_user = users.get_current_user() default_service_identity_user = create_service_identity_user(service_user, ServiceIdentity.DEFAULT) app_id = get_and_validate_app_id_for_service_identity_user(default_service_identity_user, app_id, email) try: user_profile = bizz_add_broadcast_test_person(service_user, create_app_user(users.User(email), app_id)) r.user_details = UserDetailsTO.fromUserProfile(user_profile) r.success = True r.errormsg = None except BusinessException, be: r.user_details = None r.success = False r.errormsg = be.message.decode('UTF-8') if be.message is not None else None
def rebuild_synced_roles(members, service_identities): """ Rebuilds access to service_identies based on SYNCED roles. If members is empty or None, access for all members of service_identities will be checked. If service_identies is empty or None, access for members of all service_identities will be checked. """ from rogerthat.bizz.job.rebuild_synced_roles import schedule_rebuild_synced_roles service_user = users.get_current_user() if members in (None, MISSING): members = list() if service_identities in (None, MISSING): service_identities = list() schedule_rebuild_synced_roles(service_user, [create_app_user(users.User(m.member), m.app_id) for m in members], [create_service_identity_user(service_user, si_id) for si_id in service_identities])
def messageFlowMemberResult(request): # type: (MessageFlowMemberResultRequestTO) -> None from rogerthat.bizz.messaging import send_message_flow_member_result, send_message_flow_results_email from rogerthat.dal import parent_key from rogerthat.dal.service import get_service_interaction_def app_user = users.get_current_user() run = request.run sender = add_slash_default(users.User(run.sender)) svc_user, service_identity = get_service_identity_tuple(sender) tag = None if run.hashed_tag != MISSING: mapped_tag = ServiceMenuDefTagMap.get_by_key_name(run.hashed_tag, parent=parent_key(svc_user)) if mapped_tag: tag = mapped_tag.tag elif run.service_action != MISSING: if "?" in run.service_action: # strip off the query parameters added by shortner.py run.service_action = run.service_action[:run.service_action.index("?")] sid = get_service_interaction_def(svc_user, int(run.service_action)) if sid: tag = sid.tag elif run.message_flow_run_id: message_flow_run = MessageFlowRunRecord.get_by_key_name( MessageFlowRunRecord.createKeyName(svc_user, run.message_flow_run_id)) if message_flow_run: tag = message_flow_run.tag if request.end_id: from rogerthat.bizz.messaging import check_test_flow_broadcast_ended check_test_flow_broadcast_ended(app_user, create_service_identity_user(svc_user, service_identity), run.parent_message_key, tag) if run.steps and run.steps[-1].acknowledged_timestamp is MISSING: logging.warn('Last step is not yet ACKed! Patching...') run.steps = run.steps[:-1] if request.results_email and request.results_email is not MISSING: send_message_flow_results_email(request.message_flow_name, request.emails, request.email_admins, run.steps, app_user, service_identity, svc_user, run.parent_message_key, tag) else: flow_params = run.flow_params if run.flow_params is not MISSING else None send_message_flow_member_result(svc_user, service_identity, run.message_flow_run_id, run.parent_message_key, app_user, run.steps, request.end_id, request.flush_id, tag=tag, flow_params=flow_params, timestamp=MISSING.default(request.timestamp, now()))
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 _4500_migrate_qrs(job_key): phase = MigrateServiceJob.PHASE_4500_MIGRATE_QRS next_phase = MigrateServiceJob.PHASE_5000_MIGRATE_NON_ANCESTOR_MODELS # Validate that the job still exists job = _get_job(job_key, phase) # Do the work _log_progress(job) logging.info("1/ Migrate recommendation QR codes") def trans_migrate_recommend_qrs(): # Get SIs with recommend enabled service_identities = [si for si in get_service_identities_query(job.from_service_user) if si.shareSIDKey] if service_identities: old_sid_keys = map(db.Key, [si.shareSIDKey for si in service_identities]) old_sid_keys = [k for k in old_sid_keys if k.parent().name() != job.to_service_user.email()] logging.info('Old recommendation QR codes: %s', old_sid_keys) if old_sid_keys: old_sids = db.get(old_sid_keys) new_sids = _migrate_sids(job, old_sids) for si, new_sid in zip(service_identities, new_sids): si.shareSIDKey = str(new_sid.key()) put_and_invalidate_cache(*service_identities) logging.info('New recommendation QR codes: %s', [new_sid.key() for new_sid in new_sids]) else: logging.debug("No ServiceIdentity with recommendation enabled") xg_on = db.create_transaction_options(xg=True) db.run_in_transaction_options(xg_on, trans_migrate_recommend_qrs) logging.info("2/ Migrate all other QR codes") qry = ServiceInteractionDef.all().ancestor(parent_key(job.from_service_user)) def trans_migrate_other_qrs(): old_sids = qry.fetch(100) if not old_sids: return False _migrate_sids(job, old_sids) return True while db.run_in_transaction_options(xg_on, trans_migrate_other_qrs): pass # run trans until it returns False logging.info("3/ Migrate all ProfilePointers") old_pp_keys = list() new_pps = list() for si_key in get_service_identities_query(job.from_service_user, keys_only=True): identity = si_key.name() old_si_user = create_service_identity_user(job.from_service_user, identity) new_si_user = create_service_identity_user(job.to_service_user, identity) old_pp_keys.append(ProfilePointer.create_key(old_si_user)) new_pps.append(ProfilePointer.create(new_si_user)) put_and_invalidate_cache(*new_pps) db.delete(old_pp_keys) # Set the next phase _set_job_in_next_phase(job_key, phase, next_phase)
def _7000_migrate_solution(job_key): phase = MigrateServiceJob.PHASE_7000_MIGRATE_SOLUTION next_phase = MigrateServiceJob.PHASE_8000_FINISH_MODELS # Validate that the job still exists job = _get_job(job_key, phase) # Do the work _log_progress(job) if job.solution: logging.info('0/ Migrate the solution models without ancestor, but with service_user as key name.') def trans0(): new_models = list() old_models = list() for model_class in (SolutionMainBranding, SolutionLogo, SolutionAvatar): old_model = db.get(model_class.create_key(job.from_service_user)) if old_model: kwargs = copy_model_properties(old_model) new_model = model_class(key=model_class.create_key(job.to_service_user), **kwargs) new_models.append(new_model) old_models.append(old_model) if new_models: put_and_invalidate_cache(*new_models) if old_models: db.delete(old_models) xg_on = db.create_transaction_options(xg=True) db.run_in_transaction_options(xg_on, trans0) old_sln_settings = get_solution_settings(job.from_service_user) identities = [None] if old_sln_settings.identities: identities.extend(old_sln_settings.identities) logging.info('1/ Migrate RestaurantReservations') for service_identity in identities: from_si_user = create_service_identity_user_wo_default(job.from_service_user, service_identity) to_si_user = create_service_identity_user_wo_default(job.to_service_user, service_identity) while True: reservations = RestaurantReservation.all().filter('service_user', from_si_user).fetch(300) if not reservations: break for r in reservations: r.service_user = to_si_user _put_and_invalidate_cache_and_allocate_ids(*reservations) logging.info('2/ Migrate EventReminders') for service_identity in identities: from_si_user = create_service_identity_user(job.from_service_user) to_si_user = create_service_identity_user(job.to_service_user) while True: reminders = EventReminder.all().filter('service_identity_user', from_si_user).fetch(300) if not reminders: break for r in reminders: r.service_identity_user = to_si_user _put_and_invalidate_cache_and_allocate_ids(*reminders) logging.info('3/ Migrate RestaurantProfile.reserve_flow_part2') restaurant_profile = db.get(RestaurantProfile.create_key(job.from_service_user)) if restaurant_profile and restaurant_profile.reserve_flow_part2: old_part2_key = db.Key(restaurant_profile.reserve_flow_part2) new_part2_key = db.Key.from_path(old_part2_key.kind(), old_part2_key.id_or_name(), parent=parent_key(job.to_service_user)) logging.debug('New key: %r', new_part2_key) restaurant_profile.reserve_flow_part2 = str(new_part2_key) _put_and_invalidate_cache_and_allocate_ids(restaurant_profile) logging.info('4/ Delete all SolutionQRs. They will be recreated when provisioning.') for service_identity in identities: service_identity_user = create_service_identity_user_wo_default(job.from_service_user, service_identity) db.delete(SolutionQR.all(keys_only=True).ancestor(parent_key_unsafe(service_identity_user, job.solution))) logging.info('5/ Delete Loyalty QR. It will be recreated when provisioning.') if SolutionModule.LOYALTY in old_sln_settings.modules: for service_identity in identities: if is_default_service_identity(service_identity): loyalty_i_settings = db.get(SolutionLoyaltySettings.create_key(job.from_service_user)) else: loyalty_i_settings = db.get( SolutionLoyaltyIdentitySettings.create_key(job.from_service_user, service_identity)) if loyalty_i_settings: loyalty_i_settings.image_uri = None loyalty_i_settings.content_uri = None _put_and_invalidate_cache_and_allocate_ids(loyalty_i_settings) logging.info('6/ Change ancestor keys of solution models.') for solution in ['common', job.solution]: for service_identity in identities: if is_default_service_identity(service_identity): _migrate_ancestor_models(job, parent_key(job.from_service_user, solution)) else: service_identity_user = create_service_identity_user_wo_default( job.from_service_user, service_identity) _migrate_ancestor_models(job, parent_key_unsafe(service_identity_user, solution)) sln_settings = get_solution_settings(job.to_service_user) sln_main_branding = get_solution_main_branding(job.to_service_user) users.set_user(job.to_service_user) try: populate_identity(sln_settings, sln_main_branding.branding_key) finally: users.clear_user() # Set the next phase _set_job_in_next_phase(job_key, phase, next_phase)
def _re_index_service_identity(si_key): service_user = users.User(si_key.parent().name()) si_user = create_service_identity_user(service_user, si_key.name()) re_index(si_user)
def _delete_search_indexes(service_user): for si_key in ServiceIdentity.all(keys_only=True).ancestor(parent_key(service_user)): deferred.defer(remove_service_identity_from_index, create_service_identity_user(service_user, si_key.name()), _queue=MIGRATION_QUEUE)
def rest_put_news_item( title, message, broadcast_type, image, sponsored=False, action_button=None, order_items=None, type=MISSING, qr_code_caption=MISSING, app_ids=MISSING, # @ReservedAssignment scheduled_at=MISSING, news_id=None, broadcast_on_facebook=False, broadcast_on_twitter=False, facebook_access_token=None, target_audience=None, role_ids=None): """ Args: title (unicode) message (unicode) broadcast_type (unicode) sponsored (bool) image (unicode) action_button (NewsButtonTO) order_items (list of OrderItemTO) type (int) qr_code_caption (unicode) app_ids (list of unicode) scheduled_at (long) news_id (long): id of the news to update. When not specified a new item is created broadcast_on_facebook (bool) broadcast_on_twitter (bool) facebook_access_token (unicode): user or page access token target_audience (NewsTargetAudienceTO) role_ids (list of long) """ service_user = users.get_current_user() session_ = users.get_current_session() service_identity = session_.service_identity if is_default_service_identity(service_identity): service_identity_user = create_service_identity_user(service_user) else: service_identity_user = create_service_identity_user( service_user, service_identity) try: host = get_current_http_host() return put_news_item(service_identity_user, title, message, broadcast_type, sponsored, image, action_button, order_items, type, qr_code_caption, app_ids, scheduled_at, news_id, broadcast_on_facebook, broadcast_on_twitter, facebook_access_token, target_audience=target_audience, role_ids=role_ids, host=host, accept_missing=True) except BusinessException as e: sln_settings = get_solution_settings(service_user) try: message = common_translate(sln_settings.main_language, SOLUTION_COMMON, e.message) except ValueError: message = e.message return ReturnStatusTO.create(False, message)
def service_identity_user(self): return create_service_identity_user(self.service_user, self.service_identity)
def get_broadcast_statistics_excel(service_user, service_identity): """ Generates an excel file containing the broadcast statistics. Format: Date | Sent to | Received | Read | Acknowledged | Message Args: service_user(users.User): Service user Returns: Excel file """ sln_settings = get_solution_settings(service_user) lang = sln_settings.main_language def transl(key): return translate(lang, SOLUTION_COMMON, key) if is_default_service_identity(service_identity): service_identity_user = create_service_identity_user(service_user, ServiceIdentity.DEFAULT) else: service_identity_user = create_service_identity_user(service_user, service_identity) bc_stats = BroadcastStatistic.get_all_by_service_identity_user(service_identity_user).order('timestamp') column_timestamp = 0 column_sent = 1 column_received = 2 column_read = 3 # column_acknowledged = 4 column_message = 4 bold_style = xlwt.XFStyle() bold_style.font.bold = True book = xlwt.Workbook(encoding="utf-8") messages_sheet = book.add_sheet(transl('broadcast_statistics')[0:31]) messages_sheet.write(0, column_timestamp, transl('Date'), bold_style) messages_sheet.write(0, column_sent, transl('sent_to'), bold_style) messages_sheet.write(0, column_received, transl('received'), bold_style) messages_sheet.write(0, column_read, transl('Read'), bold_style) # messages_sheet.write(0, column_acknowledged, transl('acknowledged'), bold_style) messages_sheet.write(0, column_message, transl('inbox-message'), bold_style) messages_sheet.col(column_timestamp).width = 6000 messages_sheet.col(column_sent).width = 5000 messages_sheet.col(column_received).width = 5000 messages_sheet.col(column_read).width = 5000 # messages_sheet.col(column_acknowledged).width = 5000 messages_sheet.col(column_message).width = 20000 for i, statistic in enumerate(bc_stats): i += 1 if statistic.timestamp: datetime_string = format_datetime(datetime.datetime.utcfromtimestamp(statistic.timestamp), locale=lang, tzinfo=sln_settings.tz_info) else: datetime_string = '' messages_sheet.write(i, column_timestamp, datetime_string) messages_sheet.write(i, column_message, statistic.message or '') messages_sheet.write(i, column_sent, statistic.sent or 0) messages_sheet.write(i, column_received, statistic.received or 0) messages_sheet.write(i, column_read, statistic.read or 0) # messages_sheet.write(i, column_acknowledged, statistic.acknowledged or 0) excel_file = StringIO() book.save(excel_file) return excel_file.getvalue()