Python service.remove_slash_default函数代码示例

    def test_invite_response_with_user_data(self):
        user_data = {'test1': 'bla1', 'test2': 'bla2'}

        # friend invites svc_identity_user
        invitor = users.get_current_user()

        svc_user = users.User(u's%[email protected]' % time.time())
        si = create_service_profile(svc_user, u"Default name")[1]

        self.assertIsNone(db.get(UserData.createKey(invitor, si.user)))

        invite(invitor, remove_slash_default(si.user).email(), None, None, None,
               None, origin=ORIGIN_USER_INVITE, app_id=App.APP_ID_ROGERTHAT)
        invited_response_receiver(UNIT_TEST_REFS["invited"], json.dumps(user_data))
        myFriendMap = get_friends_map(invitor)
        assert remove_slash_default(si.user) in myFriendMap.friends
        assert myFriendMap.generation > 0
        assert get_friend_serviceidentity_connection(invitor, si.user)

        ud = db.get(UserData.createKey(invitor, si.user))
        self.assertIsNotNone(ud)
        helper = FriendHelper.from_data_store(si.user, FRIEND_TYPE_SERVICE)
        user_data_string = FriendTO.fromDBFriendMap(helper, myFriendMap, si.user, True, True, invitor).userData
        self.assertIsNone(user_data_string)
        ud_dict = ud.userData.to_json_dict()
        ud_dict['__rt__disabledBroadcastTypes'] = ud_dict.get('__rt__disabledBroadcastTypes', [])
        user_data['__rt__disabledBroadcastTypes'] = list()
        self.assertDictEqual(user_data, ud_dict)

        # test cleanup of UserData
        breakFriendShip(invitor, si.user)
        self.assertIsNone(db.get(UserData.createKey(invitor, si.user)))

def add_new_beacon_discovery(app_user, beacon_uuid, beacon_name):
    '''A human user has discovered a beacon'''
    beacon_uuid = beacon_uuid.lower()
    beacon = get_beacon(beacon_uuid, beacon_name)
    if not beacon:
        logging.warn("Beacon not found: {uuid: %s, name: %s}", beacon_uuid, beacon_name)
        return None, None

    keyy = BeaconDiscovery.create_key(app_user, beacon.service_identity_user)
    beaconDiscovery = BeaconDiscovery.get(keyy)
    if beaconDiscovery:
        return beacon.service_identity_user, beacon.tag

    BeaconDiscovery(key=keyy, creation_time=now()).put()

    si = get_service_identity(beacon.service_identity_user)
    if not si:
        logging.error("Service identity not found for service_identity_user: %s" % beacon.service_identity_user)
    elif not si.beacon_auto_invite:
        logging.info("Beacon detected but %s does not allow auto invite {user %s, uuid: %s, name: %s}",
                     beacon.service_identity_user, app_user, beacon_uuid, beacon_name)
    elif get_app_id_from_app_user(app_user) not in si.appIds:
        logging.info("Beacon detected but %s does not contain app_id of user %s: {uuid: %s, name: %s}",
                     beacon.service_identity_user, app_user, beacon_uuid, beacon_name)
        return None, None
    elif get_friend_serviceidentity_connection(app_user, beacon.service_identity_user):
        logging.info("Beacon detected but %s and %s were already friends: {uuid: %s, name: %s}",
                     app_user, beacon.service_identity_user, beacon_uuid, beacon_name)
    else:
        # Fake a deleted connection between service and human user to be able to show the service's avatar on the phone
        friend_map = get_friends_map(app_user)
        friend_map.generation += 1
        friend_map.version += 1
        friend_map.put()

        friend_detail = FriendDetails().addNew(remove_slash_default(beacon.service_identity_user),
                                               si.name, si.avatarId, type_=FriendDetail.TYPE_SERVICE)
        friend_detail.relationVersion = -1

        from rogerthat.bizz.job.update_friends import _do_update_friend_request
        _do_update_friend_request(app_user, friend_detail, UpdateFriendRequestTO.STATUS_ADD, friend_map,
                                  extra_conversion_kwargs=dict(existence=FriendTO.FRIEND_EXISTENCE_DELETED,
                                                               includeServiceDetails=False))

        user_profile = get_user_profile(app_user)
        app_name = get_app_name_by_id(user_profile.app_id)
        m = localize(user_profile.language, "_automatic_detection_invitation", app_name=app_name, service_name=si.name)
        _send_invitation_message_from_service_to_user(app_user, beacon.service_identity_user, m,
                                                      si.descriptionBranding, user_profile.language,
                                                      ORIGIN_BEACON_DETECTED, BEACON_DISCOVERY)

        message = "Beacon detected at %s (%s) with tag: %s" % (si.name.encode('utf8'),
                                                               remove_slash_default(si.service_identity_user).email().encode('utf8'),
                                                               beacon.tag.encode('utf8'))

        server_settings = get_server_settings()
        xmpp.send_message(server_settings.xmppInfoMembers, message, message_type=xmpp.MESSAGE_TYPE_CHAT)

    return beacon.service_identity_user, beacon.tag

 def has_access(self, email):
     from rogerthat.utils.service import remove_slash_default
     if remove_slash_default(users.User(email)) == remove_slash_default(self.user):
         return True
     logging.info("Looking for access of %s in service users %s", email, self.service_users_blob)
     for si in self.service_users:
         if email in (si["service_user"], si["service_identity_user"]):
             return True
     return False

    def fromServiceIdentity(service_identity, target_language, distance=-1, avatar_size=50, actions=None):
        """
        Args:
            service_identity (ServiceIdentity)
            target_language (unicode)
            distance (int)
            avatar_size (int)
        """
        from rogerthat.pages.profile import get_avatar_cached
        from rogerthat.bizz.i18n import get_translator

        translator = get_translator(service_identity.service_user, ServiceTranslation.IDENTITY_TYPES, target_language)

        entry = FindServiceItemTO()
        entry.email = remove_slash_default(service_identity.user).email()
        entry.avatar_id = service_identity.avatarId  # Web support
        entry.avatar = unicode(base64.b64encode(get_avatar_cached(service_identity.avatarId, avatar_size)))
        entry.description_branding = translator.translate(ServiceTranslation.IDENTITY_BRANDING,
                                                          service_identity.descriptionBranding, target_language)
        entry.description = translator.translate(ServiceTranslation.IDENTITY_TEXT, service_identity.description,
                                                 target_language)
        entry.name = translator.translate(ServiceTranslation.IDENTITY_TEXT, service_identity.name, target_language)
        entry.qualified_identifier = translator.translate(ServiceTranslation.IDENTITY_TEXT,
                                                          service_identity.qualifiedIdentifier, target_language)
        if actions:
            entry.detail_text = actions
        elif distance >= 0:
            entry.detail_text = localize(target_language, 'Distance: %(distance)s km', distance=distance)
        else:
            entry.detail_text = None

        return entry

 def fromDBFriendDetail(friendDetail):
     fr = FriendRelationTO()
     fr.email = remove_app_id(remove_slash_default(users.User(friendDetail.email), warn=True)).email()
     fr.name = friendDetail.name
     fr.avatarId = friendDetail.avatarId
     fr.type = friendDetail.type
     return fr

    def __init__(self, news_id=0, sender_email=None, sender_name=None, sender_avatar_id=0, title=None,
                 message=None, image_url=None, broadcast_type=None, reach=0, users_that_rogered=None, buttons=None,
                 qr_code_content=None, qr_code_caption=None, version=0, timestamp=0, flags=0, news_type=1, media=None):

        if users_that_rogered is None:
            users_that_rogered = []
        if buttons is None:
            buttons = []
        self.id = news_id
        if sender_email:
            sender_email = remove_slash_default(users.User(sender_email)).email()
        self.sender = NewsSenderTO(sender_email, sender_name, sender_avatar_id)
        self.title = title
        self.message = message
        self.image_url = image_url
        self.broadcast_type = broadcast_type
        self.reach = reach
        self.users_that_rogered = users_that_rogered
        self.buttons = [NewsActionButtonTO.from_model(button) for button in buttons]
        self.qr_code_content = qr_code_content
        self.qr_code_caption = qr_code_caption
        self.version = version
        self.timestamp = timestamp
        self.flags = flags
        self.type = news_type
        self.media = media

def _match_target_audience_of_item(app_user, news_item):
    target_audience = news_item.target_audience
    if not target_audience:
        return True
    profile = get_user_profile(app_user)
    if not profile:
        return False
    if profile.birthdate is None or not profile.gender >= 0:
        return False

    news_item_gender = target_audience.gender
    any_gender = (UserProfile.GENDER_MALE_OR_FEMALE, UserProfile.GENDER_CUSTOM)
    if news_item_gender not in any_gender:
        if profile.gender != news_item_gender:
            return False

    min_age = target_audience.min_age
    max_age = target_audience.max_age
    user_birthdate = date.fromtimestamp(profile.birthdate)
    user_age = calculate_age_from_date(user_birthdate)
    if not (min_age <= user_age <= max_age):
        return False

    if target_audience.connected_users_only:
        friends_map = get_friends_map_cached(app_user)
        if remove_slash_default(news_item.sender) not in friends_map.friends:
            return False
    return True

    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 trans():
        if isinstance(friend_map_or_key, FriendMap):
            friend_map = friend_map_or_key
        elif isinstance(friend_map_or_key, db.Key):
            friend_map = db.get(friend_map_or_key)
        else:
            friend_map = get_friends_map(target_user)

        if status == UpdateFriendRequestTO.STATUS_DELETE:
            friend_detail = None
        else:
            try:
                friend_detail = friend_map.friendDetails[remove_slash_default(updated_user).email()]
            except KeyError:
                logging.warn("%s not found in the friendMap of %s. Not sending updateFriend request with status=%s",
                             remove_slash_default(updated_user), target_user, status)
                return None
        return _do_update_friend_request(target_user, friend_detail, status, friend_map, bump_friend_map_generation,
                                         extra_conversion_kwargs, skip_mobiles)

 def fromServiceIdentity(service_identity):
     from rogerthat.utils.service import remove_slash_default
     si = ServiceIdentityInfoTO()
     si.name = service_identity.name
     si.email = remove_slash_default(service_identity.user).email()
     si.avatar = service_identity.avatarUrl
     si.admin_emails = list() if service_identity.metaData is None else [e.strip() for e in service_identity.metaData.split(',') if e.strip()]
     si.description = service_identity.description
     si.app_ids = service_identity.appIds
     return si

 def fromMessageMemberStatus(message, memberStatus):
     ms = MemberStatusTO()
     ms.member = remove_app_id(remove_slash_default(message.members[memberStatus.index], warn=True)).email()
     ms.acked_timestamp = memberStatus.acked_timestamp
     if memberStatus.button_index != -1:
         ms.button_id = message.buttons[memberStatus.button_index].id
     else:
         ms.button_id = None
     ms.custom_reply = memberStatus.custom_reply
     ms.received_timestamp = memberStatus.received_timestamp
     ms.status = memberStatus.status
     return ms

def beacon_discovered(request):
    from rogerthat.rpc import users
    from rogerthat.bizz.beacon import add_new_beacon_discovery
    app_user = users.get_current_user()
    response = BeaconDiscoveredResponseTO()
    service_identity_user, tag = add_new_beacon_discovery(app_user, request.uuid, request.name)
    if service_identity_user:
        response.friend_email = remove_slash_default(service_identity_user).email()
    else:
        response.friend_email = None
    response.tag = tag
    return response

def get_profile_info_name(user, app_id):
    if user == MC_DASHBOARD:
        app_name = get_app_name_by_id(app_id)
        if app_id == App.APP_ID_ROGERTHAT:
            return u"%s Dashboard" % app_name
        else:
            return app_name
    else:
        profile_info = get_profile_info(user)
        if profile_info:
            return profile_info.name or profile_info.qualifiedIdentifier or remove_slash_default(user).email()
        else:
            return user.email()

def create_update_friend_requests(helper, updated_user, friend_map, status, extra_conversion_kwargs=None,
                                  skip_mobiles=None):
    """
    Sends the correct request (UpdateFriendRequest or UpdateFriendSetRequest) to the client,
    based on the version of the mobile.

    Args:
        helper(FriendHelper):
        updated_user(users.User): The user which has been updated.
        friend_map(FriendMap): Friend map of the target user
        status(int): The kind of friend update. See UpdateFriendRequestTO.STATUS_*
        extra_conversion_kwargs(dict): Optional kwargs to pass to the FriendTO.fromDBFriendDetail method.
        skip_mobiles([unicode]): mobile accounts that should be skipped.
    Returns:
        list[RpcCAPICall]
    """
    azzert(status in (UpdateFriendRequestTO.STATUS_ADD,
                      UpdateFriendRequestTO.STATUS_DELETE,
                      UpdateFriendRequestTO.STATUS_MODIFIED))
    target_user = friend_map.user

    if status == UpdateFriendRequestTO.STATUS_DELETE:
        friend_detail = None
    else:
        try:
            friend_detail = friend_map.friendDetails[remove_slash_default(updated_user).email()]
        except KeyError:
            logging.warn("%s not found in the friendMap of %s. Not sending updateFriend request with status=%s",
                         remove_slash_default(updated_user), target_user, status)
            friend_detail = None
    if not friend_detail:
        return []
    friend_to = convert_friend(helper, target_user, friend_detail, status, extra_conversion_kwargs)

    capi_calls = do_update_friend_request(target_user, friend_to, status, friend_map, helper, skip_mobiles)
    if friend_to and helper.is_service:
        channel.send_message(target_user, u'rogerthat.friends.update', friend=friend_to.to_dict())
    return capi_calls

 def fromServiceIdentity(service_identity):
     from rogerthat.utils.service import remove_slash_default
     to = ServiceIdentityInfoTO()
     to.name = service_identity.name
     to.email = remove_slash_default(service_identity.user).email()
     to.avatar = service_identity.avatarUrl
     to.admin_emails = [] if service_identity.metaData is None else [e.strip() for e in
                                                                     service_identity.metaData.split(',') if
                                                                     e.strip()]
     to.description = service_identity.description
     apps = get_apps_by_id(service_identity.appIds)
     to.app_ids = [app.app_id for app in apps if app]
     to.app_names = [app.name for app in apps if app]
     return to