コード例 #1
0
def sms(main_number):
    phone_num = main_number
    module = Atom('Auth')
    client_id = []  # client_id   = [] :: [] | binary(),
    dev_key = phone_num  # dev_key     = [] :: [] | binary(),
    user_id = []  # user_id     = [] :: [] | binary(),
    phone = phone_num  # phone       = [] :: [] | binary(),
    token = []  # token       = [] :: [] | binary(),
    sms_code = '903182'  # type        = [] :: [] | atom(),
    type_r = Atom('verify')  # sms_code    = [] :: [] | binary(),
    attempts = []  # attempts    = [] :: [] | integer(),
    services = []  # services    = [] :: list(atom()),
    settings = [('Feature', "id_DEFAULT_LANGUAGE", "DEFAULT_LANGUAGE",
                 "English:en", "LANGUAGE_SETTING")]
    push = []  # push        = [] :: [] | binary(),
    os = []  # os          = [] :: [] | atom() | ios | android | web,
    created = []  # created     = [] :: [] | integer() | binary(),
    last_online = []  # last_online = [] :: [] | integer()})
    request_f = (module, client_id, dev_key, user_id, phone, token, type_r,
                 sms_code, attempts, services, settings, push, os, created,
                 last_online)
    request = bert.encode(request_f)
    # log.info('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(request_f)+'\r\n')
    log.debug("Send sms verify")
    return request
コード例 #2
0
def login(main_number):
    phone_num = main_number
    feature = Atom('Feature')
    module = Atom('Auth')
    client_id = "reg_" + phone_num  # client_id   = [] :: [] | binary(),
    dev_key = phone_num  # dev_key     = [] :: [] | binary(),
    user_id = []  # user_id     = [] :: [] | binary(),
    phone = phone_num  # phone       = [] :: [] | binary(),
    token = []  # token       = [] :: [] | binary(),
    sms_code = []  # type        = [] :: [] | atom(),
    type_r = Atom('reg')  # sms_code    = [] :: [] | binary(),
    attempts = []  # attempts    = [] :: [] | integer(),
    services = []  # services    = [] :: list(atom()),
    # settings    = [] :: [] | list(#'Feature'{}),
    settings = [(feature, phone_num + "__152775413346297", "AppVersion",
                 "0.2.95", "AUTH_DATA"),
                (feature, phone_num + "__152775413346297", "OS", "iOS 11.3",
                 "AUTH_DATA"),
                (feature, phone_num + "__152775413346297", "DeviceModel",
                 "simulator/sandbox", "AUTH_DATA")]
    push = []  # push        = [] :: [] | binary(),
    os = []  # os          = [] :: [] | atom() | ios | android | web,
    created = []  # created     = [] :: [] | integer() | binary(),
    last_online = []  # last_online = [] :: [] | integer()})
    request_f = (module, client_id, dev_key, user_id, phone, token, type_r,
                 sms_code, attempts, services, settings, push, os, created,
                 last_online)
    request = bert.encode(request_f)
    # log.info('='*5 + 'REQUEST' + '='*5 + '\r\n' + str(request_f)+'\r\n')
    log.debug("Send Auth/check")
    return request
コード例 #3
0
def delete_user(phone_number):
    Profile = Atom('Profile')
    remove = Atom('remove')
    user_delete_f = (Profile, phone_number, [], [], [], [], [], [], remove)
    print('=' * 5 + 'REQUEST' + '=' * 5 + '\r\n' + str(user_delete_f) + '\r\n')
    user_delete = bert.encode(user_delete_f)
    return user_delete
コード例 #4
0
def patch_group(room_id, room_name):
    module = Atom('Room')
    room_id = room_id                                               # id          = [] :: [] | binary(),
    name = room_name                                                # name        = [] :: [] | binary(),
    links = []
    description = []                                                # description = [] :: [] | binary(),
    settings = []                                                   # settings    = [] :: list(),
    members = []                                                    # members     = [] :: list(#'Member'{}),
    admins = []                                                     # admins      = [] :: list(#'Member'{}),
    data = []                                                       # data        = [] :: [] | list(#'Desc'{}),
    room_type = []                                                  # type        = [] :: [] | atom() | group | channel,
    tos = []                                                        # tos         = [] :: [] | binary(),
    tos_update = []                                                 # tos_update  = 0  :: [] | integer(),
    unread = []                                                     # unread      = 0  :: [] | integer(),
    mentions = []                                                   # mentions    = [] :: [] | list(integer()),
    readers = []                                                    # readers     = [] :: list(integer()),
    last_msg = []                                                   # last_msg    = [] :: [] | #'Message'{},
    update = []                                                     # update      = 0  :: [] | integer(),
    created = []                                                    # created     = 0  :: [] | integer(),
    room_status = Atom('patch')                                    #  status      = [] :: [] | create | leave| add | remove | patch | get | delete | last_msg}).

    request_f = (module,room_id,name,links,description,settings,members,admins,data,room_type,
                 tos,tos_update,unread,mentions,readers,last_msg,update,created,room_status)

    request = bert.encode(request_f)
    # log.info('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(request_f)+'\r\n')
    log.debug("Send group creation request")
    return request
コード例 #5
0
def parser(client, payload, main_number):
    data = bert.decode(bytes(payload))

    if data[0] == Atom("Profile"):
        contacts = data[3][0][6]
        for field in contacts:
            if field[0] == Atom('Contact') and field[1].split(
                    b'_')[0] == string_to_bytes(main_number):
                log.debug('Main profile found')
                global user_id
                user_id = field[1]
                print(user_id)
        for field in data:
            if field and list == type(field):
                for room in field[0]:
                    if room and list == type(room) and room[0][0] == Atom(
                            'Room'):
                        global room_id
                        room_id = room[-1][1]
                        print(room_id)
        client.publish(topic="events/1//api/anon//",
                       payload=bytearray(history_group(user_id, room_id)),
                       qos=2,
                       retain=False)

    if data[0] == Atom('Message') and data[-1] == Atom('clear'):
        log.debug("Verify history removed")
        for field in data:
            if field and list == type(field) and tuple == type(field[0]):
                Verify.equals(b'History was removed', field[0][3],
                              'No history removed')
        client.disconnect()
コード例 #6
0
def get_profile():
    module = Atom('Profile')
    phone_id = '12566018988'
    settings = []
    status = Atom('get')

    request_f = (module,phone_id,settings,settings,settings,settings,settings,settings,status)
    request = bert.encode(request_f)
    print('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(request_f)+'\r\n')
    return request
コード例 #7
0
 def on_message(self, client, userdata, msg):
     log.info('='*5 + 'RESPONSE' + '='*5 + '\r\n'+ str(bert.decode(bytes(msg.payload))) + '\r\n')
     for node in (bert.decode(bytes(msg.payload))):
         if node == (Atom('ok'), Atom('sms_sent')):
             client.publish(topic="events/1//api/anon//", payload=bytearray(sms(self.my_number)), qos=2,
                            retain=False)
         if re.findall(r"\(Atom\('ok2'\), Atom\('login'\)", str(node)):
             self.clien = str(node[2][0].decode("utf-8"))
             self.pswd = str(node[2][1].decode("utf-8"))
             log.info('Got client {} and password {}'.format(self.clien, self.pswd))
             client.disconnect()
コード例 #8
0
def ban_user():
    module = Atom('Friend')
    phone_id = '8613777322455_544'  # phone_id  = [] :: [] | binary(),
    friend_id = '380998681837_437'  # friend_id = [] :: [] | binary(),
    settings = []  # settings  = [] :: list(#'Feature'{}),
    status = Atom('ban')  # status    = [] :: [] | ban | unban
    # | request | confirm | update
    request_f = (module, phone_id, friend_id, settings, status)
    request = bert.encode(request_f)
    print('=' * 5 + 'REQUEST' + '=' * 5 + '\r\n' + str(request_f) + '\r\n')
    return request
コード例 #9
0
def ignore_request():
    module = Atom('Friend')
    phone_id = '12566018988_727'            # phone_id  = [] :: [] | binary(),
    friend_id = '51997259024_549'                          # friend_id = [] :: [] | binary(),
    settings = []                           # settings  = [] :: list(#'Feature'{}),
    status = Atom('ignore')                 # status    = [] :: [] | ban | unban
                                            # | request | confirm | update
    request_f = (module,phone_id,friend_id,settings,status)
    request = bert.encode(request_f)
    print('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(request_f)+'\r\n')
    return request
コード例 #10
0
def history_schedule():
    model = Atom('History')
    user_id = '38000000001_13825'               # roster_id = [] :: [] | binary(),
    history_type = Atom('act')
    name = 'publish'                            # name = <<"publish">> :: [] | binary(),
    dt = '38000000001_13825'                    # data = []:: binary() | integer() | list(term())})
    action = Atom('get')
    size = []                                   # size      = 0 :: [] | integer(),
    entity_id = []                              # entity_id = 0 :: [] | integer(),
    data = []                                   # data      = [] :: list(#'Message'{}) | list(#'Job'{}),
    request_f = (model,user_id,(history_type,name,dt),size,entity_id,data,action)
    request = bert.encode(request_f)
    print('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(request_f)+'\r\n')
    return request
コード例 #11
0
def history_group(user_id, group_id):
    model = Atom('History')
    user_id = user_id               # roster_id = [] :: [] | binary(),
    history_type = Atom('muc')
    group_id = group_id                # group_id = [] :: [] | binary(),
    size = []                                  # size      = 0 :: [] | integer(),
    entity_id = []                           # entity_id = 0 :: [] | integer(),
    data = []                                   # data      = [] :: list(#'Message'{}) | list(#'Job'{}),
    action = Atom('delete')
    request_f = (model,user_id,(history_type,group_id),size,entity_id,data,action)
    request = bert.encode(request_f)
    # log.debug('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(request_f)+'\r\n')
    log.debug('Clear group chat history request')
    return request
コード例 #12
0
def history_p2p():
    model = Atom('History')
    user_id = '8613777322455_544'               # roster_id = [] :: [] | binary(),
    history_type = Atom('p2p')
    from_r = '12566018988_541'                # from = [] :: [] | binary(),
    to_r = '51997259024_542'                    # to   = [] :: [] | binary()
    action = Atom('get')
    size = -15                                  # size      = 0 :: [] | integer(),
    entity_id = 20483                           # entity_id = 0 :: [] | integer(),
    data = []                                   # data      = [] :: list(#'Message'{}) | list(#'Job'{}),
    request_f = (model,user_id,(history_type,from_r,to_r),size,entity_id,data,action)
    request = bert.encode(request_f)
    print('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(request_f)+'\r\n')
    return request
コード例 #13
0
def room(**data):
    module = Atom('Room')
    expected = [
        'room_id', 'name', 'links', 'description', 'settings', 'members',
        'admins', 'data', 'room_type', 'tos', 'tos_update', 'unread',
        'mentions', 'readers', 'last_msg', 'update', 'created', 'room_status'
    ]
    actual = data
    my_dict = {}
    for i in expected:
        if i in actual.keys():
            my_dict.update({i: actual[i]})
        else:
            my_dict.update({i: []})

    request_f = (module, my_dict['room_id'], my_dict['name'], my_dict['links'],
                 my_dict['description'], my_dict['settings'],
                 my_dict['members'], my_dict['admins'], my_dict['data'],
                 my_dict['room_type'], my_dict['tos'], my_dict['tos_update'],
                 my_dict['unread'], my_dict['mentions'], my_dict['readers'],
                 my_dict['last_msg'], my_dict['update'], my_dict['created'],
                 my_dict['room_status'])

    request = bert.encode(request_f)
    log.info('=' * 5 + 'REQUEST' + '=' * 5 + '\r\n' + str(request_f) + '\r\n')
    return request
コード例 #14
0
    async def download(self, bundle):

        vault = self.vault
        assert vault is not None
        assert self.stream is not None

        self.logger.info('Downloading %s', bundle)

        # download key and file
        await self.write_term('download', bundle.store_hash)

        response = await self.read_term()

        if len(response) == 3:
            server_info = rewrite_atoms_dict(response[1])
            server_info.update(**rewrite_atoms_dict(response[2]))
            url = None
        elif len(response) == 2 and isinstance(
                response[1], tuple) and response[1][0] == Atom('url'):
            response_obj = response[1]
            url = response_obj[1].decode()
            server_info = rewrite_atoms_dict(response_obj[2])
            server_info.update(**rewrite_atoms_dict(response_obj[3]))
        else:
            raise Exception('xx')

        content_hash = server_info['content_hash'].decode()
        metadata = server_info['metadata']
        file_size = server_info['size']

        assert type(file_size) == int

        if url:
            self.logger.debug(
                'Downloading content ({} bytes) from URL: {}'.format(
                    file_size, url))
        else:
            self.logger.debug(
                'Downloading content ({} bytes) from stream.'.format(
                    file_size))

        # read content hash
        self.logger.debug('Content hash: %s', content_hash)

        await bundle.write_encrypted_metadata(Once(metadata))

        await bundle.load_key()

        if url:
            stream_source = URLReader(url)
        else:
            stream_source = TrioStreamReader(self.stream) >> Limit(file_size)

        hash_ok = await vault.crypt_engine.write_encrypted_stream(
            bundle, stream_source, assert_hash=content_hash)

        if not hash_ok:
            # alert server of hash mismatch
            await self.write_term('invalid_content_hash', bundle.store_hash,
                                  vault.revision)
コード例 #15
0
ファイル: codec.py プロジェクト: syl20bnr/python-bert
 def convert_bert(self, item):
     bert_type = item[1]
     if bert_type == "nil":
         return None
     elif bert_type == "string":
         return item[3].decode(Atom(item[2]))
     elif bert_type == "dict":
         return dict((self.convert(k), self.convert(v)) for k, v in item[2])
     elif bert_type in ("true", True):
         return True
     elif bert_type in ("false", False):
         return False
     elif bert_type == "time":
         return utc_to_datetime(item[2] * 1000000 + item[3], item[4])
     elif bert_type == "regex":
         flags = 0
         if 'extended' in item[3]:
             flags |= re.VERBOSE
         if 'caseless' in item[3]:
             flags |= re.IGNORECASE
         if 'multiline' in item[3]:
             flags |= re.MULTILINE
         if 'dotall' in item[3]:
             flags |= re.DOTALL
         return re.compile(item[2], flags)
     raise NotImplementedError("Unknown BERT type %s" % item[1])
コード例 #16
0
    def on_message(self, client, userdata, msg):
        print(msg.topic)
        print(bert.decode(bytes(msg.payload)))
        for node in (bert.decode(bytes(msg.payload))):
            if node == (Atom('ok'), Atom('sms_sent')):
                client.publish(topic="events/1//api/anon//",
                               payload=bytearray(sms),
                               qos=2,
                               retain=False)
            elif re.findall(r"\(Atom\('ok2'\), Atom\('login'\)", str(node)):
                global psw
                global clie
                clie = str(node[2][0].decode("utf-8"))
                psw = str(node[2][1].decode("utf-8"))

                client.disconnect()
コード例 #17
0
class BERTTestCase(unittest.TestCase):
    bert_tests = [
        # nil
        (None, ("bert", "nil")),
        # nested nil
        ([None, (None, )], [("bert", "nil"), (("bert", "nil"), )]),
        # unicode
        (u"Mitä kuuluu", ('bert', 'string', Atom('UTF-8'),
                          u"Mitä kuuluu".encode('utf-8'))),
        # dict
        ({
            'foo': 'bar'
        }, ('bert', 'dict', [('foo', 'bar')])),
        # empty dict
        ({}, ('bert', 'dict', [])),
        # nested dict
        ({
            'foo': {
                'baz': 'bar'
            }
        }, ('bert', 'dict', [('foo', ('bert', 'dict', [('baz', 'bar')]))])),
        # empty tuple
        (tuple(), tuple()),
        # true
        (True, ('bert', 'true')),
        # false
        (False, ('bert', 'false')),
        # time
        (datetime.datetime.utcfromtimestamp(123 * 1000000 +
                                            456).replace(microsecond=789),
         ('bert', 'time', 123, 456, 789)),
        # regex
        (re.compile('^c(a)t$', re.I | re.X),
         ('bert', 'regex', '^c(a)t$', (Atom('extended'), Atom('caseless')))),
        # other
        ([1, 2.0, ("foo", "bar")], [1, 2.0, ("foo", "bar")]),
    ]

    def testDecode(self):
        convert = BERTDecoder().convert
        for python, bert in self.bert_tests:
            self.failUnlessEqual(python, convert(bert))

    def testEncode(self):
        convert = BERTEncoder().convert
        for python, bert in self.bert_tests:
            self.failUnlessEqual(bert, convert(python))
コード例 #18
0
def desc_model(mime, payload, data):
    desc_module = Atom('Desc')
    desc_id = 'Autotest_desc_id' + str(time.time()).split('.')[0]
    desc_mime = mime
    desc_payload = payload
    parentid = []
    data = data
    return desc_module, desc_id, desc_mime, desc_payload, parentid, data
コード例 #19
0
def parser(client, payload, threadNumber):
    data = bert.decode(bytes(payload))

    for node in data:
        if node == (Atom('ok'), Atom('sms_sent')):
            client.publish(topic="events/1//api/anon//",
                           payload=bytearray(sms(threadNumber)),
                           qos=2,
                           retain=False)

        if node == Atom('Profile') and data[8] == 'remove':
            print('User {} deleted'.format(str(threadNumber)))
            client.disconnect()

        if node == Atom('Profile') and data[8] == 'init':
            client.publish(topic="events/1//api/anon//",
                           payload=bytearray(delete_user(threadNumber)),
                           qos=2,
                           retain=False)
コード例 #20
0
    async def upload_identity(self, identity: Identity, description: str):
        self.logger.debug('Uploading my public key to server')

        # upload public key and fingerprint
        await self.write_term('add_user_key', identity.export_public_key(),
                              identity.get_fingerprint(), description)

        response = await self.read_term()

        if response[0] == Atom('user_key_added'):
            raise UnexpectedResponseException()
コード例 #21
0
 async def write_term(self, *term):
     '''write a BERT tuple'''
     assert self.stream is not None
     if BINARY_DEBUG:
         self.logger.debug('[WRITE] Unserialized: %s', term)
     packet = bert.encode((Atom(term[0]), ) + term[1:])
     packet_length = len(packet)
     assert packet_length > 0
     if BINARY_DEBUG:
         self.logger.debug('[WRITE] Serialized: %s', packet)
     await self.stream.send_all(struct.pack('!I', packet_length) + packet)
コード例 #22
0
def update_username():
    model = Atom('Roster')
    user_id = 544                           # id       = [] :: [] | integer(),
    first_name = []                         # names    = [] :: [] | binary(),
    last_name = []                          # surnames = [] :: [] | binary(),
    email = []                              # email    = [] :: [] | binary(),
    my_username = '******'                  # nick     = [] :: [] | binary(),
    user_list = []                          # userlist = [] :: list(#'Contact'{}),
    room_list = []                          # roomlist = [] :: list(#'Room'{}),
    favorite = []                           # favorite = [] :: list(#'ExtendedStar'{}),
    tags = []                               # tags     = [] :: list(#'Tag'{}),
    phone = []                              # phone    = [] :: [] | binary(),
    avatar = []                             # avatar   = [] :: [] | binary(),
    update = []                             # update   = 0  :: [] | integer(),
    status = Atom('nick')                   # status   = [] :: [] | get | create | del | remove | nick | add | update
                                                               #  | list | patch | last_msg
    request_f = (model,user_id,first_name,last_name,email,my_username,user_list,room_list,favorite,
                 tags,phone,avatar,update,status)
    request = bert.encode(request_f)
    print('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(request_f)+'\r\n')
    return request
コード例 #23
0
def parser(client, payload, number, friend_phone):
    data = bert.decode(bytes(payload))

    for node in data:

        if node == Atom('Profile') and data[8] == 'init':
            roas = (bert.decode(bytes(payload))[3])
            user_id = roas[0][1]
            client.publish(topic="events/1//api/anon//",
                           payload=bytearray(search(user_id, friend_phone)),
                           qos=2,
                           retain=False)
コード例 #24
0
def act(**kwargs):
    module = Atom('act')
    expected = ['name', 'data']
    actual = kwargs

    my_dict = {}
    for i in expected:
        if i in actual.keys():
            my_dict.update({i: actual[i]})
        else:
            my_dict.update({i: []})

    return module, my_dict['name'], my_dict['data']
コード例 #25
0
def p2p(**data):
    module = Atom('p2p')
    expected = ['from_user', 'to']
    actual = data
    my_dict = {}
    for i in expected:
        if i in actual.keys():
            my_dict.update({i: actual[i]})
        else:
            my_dict.update({i: []})

    request_f = (module, my_dict['from_user'], my_dict['to'])

    return request_f
コード例 #26
0
def parser(client, payload, main_number):
    data = bert.decode(bytes(payload))

    for node in data:
        if node == Atom('Profile') and data[8] == 'init':
            roster = (bert.decode(bytes(payload))[3])
            user_id = roster[0][1]
            my = main_number + '_' + str(user_id)
            contacts = data[3][0][6]
            for field in contacts:
                if field[0] == Atom('Contact') and field[-1] == Atom('authorization'):
                    client.publish(topic="events/1//api/anon//", payload=bytearray(
                        friend(my_id=my, friend_id=field[1], status=Atom('confirm'))), qos=2, retain=False)

    if data == (Atom('io'), (Atom('error'), Atom('invalid_data')), b''):
        log.error("Something going wrong")
        client.disconnect()
        raise InvalidData("Invalid data response")

    if data == (Atom('io'), (Atom('error'), Atom('permission_denied')), b''):
        log.error("Something going wrong")
        client.disconnect()
        raise PermissionDenied("No permission")
コード例 #27
0
    async def read_term(self, assert_ok=True):
        '''reads a BERT tuple, asserts that first item is "ok"'''
        assert self.stream is not None
        pl_read = (await self.stream.receive_some(4))

        if len(pl_read) != 4:
            raise ConnectionResetException()

        pl_tuple = struct.unpack('!I', pl_read)
        packet_length = pl_tuple[0]
        assert packet_length > 0

        packet = b''
        while len(packet) < packet_length:
            buf = await self.stream.receive_some(packet_length - len(packet))
            if len(buf) == 0:
                raise ConnectionResetException()
            packet += buf

        if BINARY_DEBUG:
            logger.debug('[READ] Serialized: %s', packet)

        decoded = bert.decode(packet)

        if BINARY_DEBUG:
            self.logger.debug('[READ] Unserialized: %s', decoded)

        if assert_ok and decoded[0] != Atom('ok'):
            if decoded[0] == Atom('error'):
                if len(decoded) > 1 and decoded[1] == Atom('sync_required'):
                    raise SyncRequired()
                else:
                    raise ServerError(decoded[1:])
            else:
                raise UnsuccessfulResponse(decoded)

        return decoded
コード例 #28
0
def feature(**data):
    module = Atom('Feature')
    expected = ['id', 'key', 'value', 'group']
    actual = data
    my_dict = {}
    for i in expected:
        if i in actual.keys():
            my_dict.update({i: actual[i]})
        else:
            my_dict.update({i: []})

    request_f = (module, my_dict['id'], my_dict['key'], my_dict['value'],
                 my_dict['group'])

    return request_f
コード例 #29
0
def friend(**data):
    module = Atom('Friend')
    expected = ['my_id', 'friend_id', 'settings', 'status']
    actual = data
    my_dict = {}
    for i in expected:
        if i in actual.keys():
            my_dict.update({i: actual[i]})
        else:
            my_dict.update({i: []})

    request_f = (module, my_dict['my_id'], my_dict['friend_id'],
                 my_dict['settings'], my_dict['status'])

    by_phone = bert.encode(request_f)
    return by_phone
コード例 #30
0
def search(**data):
    module = Atom('Search')
    expected = ['user_id', 'ref', 'field', 'type_r', 'value', 'status']
    actual = data
    my_dict = {}
    for i in expected:
        if i in actual.keys():
            my_dict.update({i: actual[i]})
        else:
            my_dict.update({i: []})

    request_f = (module, my_dict['user_id'], my_dict['ref'], my_dict['field'],
                 my_dict['type_r'], my_dict['value'], my_dict['status'])

    by_phone = bert.encode(request_f)
    # log.info('='*5 + 'REQUEST' + '='*5 + '\r\n'+ str(by_phone_f)+'\r\n')
    log.debug("Search by number {}".format(str(my_dict['value'])))
    return by_phone