def add_sms(self, m):
if not isinstance(m, Message):
m = Message.from_dict(m, self.tz)
# we clean the text to avoid carriage returns in a row
column = [clean_text(m.text), self.lookup_number(m.number),
m.datetime, m]
return self.append(column)
def Send(self, sms, async_cb, async_eb):
"""
Sends SMS ``sms``
:param sms: dictionary with the settings to use
:rtype: list
"""
d = self.sconn.send_sms(Message.from_dict(sms))
return self.add_callbacks(d, async_cb, async_eb)
def Save(self, sms, async_cb, async_eb):
"""
Save a SMS ``sms`` and returns the index
:param sms: dictionary with the settings to use
:rtype: int
"""
d = self.sconn.save_sms(Message.from_dict(sms))
return self.add_callbacks(d, async_cb, async_eb)
def get_sms_cb(rawsms):
try:
sms = Message.from_pdu(rawsms[0].group('pdu'))
sms.where = int(rawsms[0].group('where'))
sms.index = index
except IndexError:
# handle bogus CMTI notifications, see #180
return None
return sms
def get_all_sms_cb(messages):
sms_list = []
for rawsms in messages:
try:
sms = Message.from_pdu(rawsms.group('pdu'))
sms.index = int(rawsms.group('id'))
sms.where = int(rawsms.group('where'))
sms_list.append(sms)
except ValueError:
log.err(ex.MalformedSMSError,
"Malformed PDU: %s" % rawsms.group('pdu'))
return sms_list
def on_save_button_clicked(self, widget):
"""This will save the selected SMS to the drafts tv and the DB"""
numl = self.get_numbers_list()
nums = ','.join(numl) if numl else ''
text = self.get_message_text()
if text:
msg = Message(nums, text, _datetime=datetime.now(self.tz))
where = TV_DICT_REV['drafts_treeview']
self.save_messages_to_db([msg], where)
self.model.unregister_observer(self)
self.view.hide()
def _cb(slist):
ret = []
# from sim storage
for dct in slist:
sms = SMMessage.from_dict(dct, self.tz)
try:
text = unpack_dbus_safe_string(sms.text)
if text[1] == '\x06': # WAP Push
dct['text'] = '%s\n%s' % \
(WAP_REPLACEMENT, text.encode('string_escape'))
sms = SMMessage.from_dict(dct, self.tz)
except ValueError:
pass
ret.append(sms)
# return messages in db storage too
lst = self.smanager.get_messages()
for msg in lst:
msg.datetime = msg.datetime.astimezone(self.tz)
ret.append(msg)
cb(ret)
def on_sms_delivery_report(self, pdu):
"""Executed when a SMS delivery report is received"""
data = SmsDeliver(pdu).data
sms = Message.from_dict(data)
assert sms.is_status_report(), "SMS IS NOT STATUS REPORT"
# XXX: O(N) here
for _sms in self.sms_pending:
if sms.ref in _sms.status_references:
# one confirmation received
_sms.status_references.remove(sms.ref)
# no more status references? Then we are done, remove it from
# the status_references list and emit signal
if not _sms.status_references:
self.sms_pending.remove(_sms)
return self.wrappee.emit_signal(SIG_SMS_DELV,
_sms.status_reference)
break
else:
log.err("Received status report with "
"unknown reference: %d" % sms.ref)
def smsc_cb(smsc):
logger.info("SMSC: %s" % smsc)
status_request = _get_sms_confirmation()
msgvp = _get_sms_validity_period()
numbers = self.get_numbers_list()
for number in numbers:
msg = Message(number, text, _datetime=datetime.now(self.tz))
self.model.device.Send(
dict(number=number,
text=text,
status_request=status_request,
smsc=smsc,
msgvp=msgvp),
dbus_interface=SMS_INTFACE,
reply_handler=lambda ref: on_sms_sent_cb(msg, ref),
error_handler=on_sms_sent_eb)
self.state = IDLE
def get_message(self, index):
dct = self.device.Get(index, dbus_interface=SMS_INTFACE)
sms = SMMessage.from_dict(dct, self.tz)
return sms
