def __init__(self,
user_id,
tokens,
alert=None,
badge=None,
sound=None,
category=None,
**kwargs):
# type: (int, List[Text], Text, int, Text, Text, **Any) -> None
self.frame = Frame()
self.tokens = tokens
expiry = int(time.time() + 24 * 3600)
priority = 10
payload = Payload(alert=alert,
badge=badge,
sound=sound,
category=category,
custom=kwargs)
for token in tokens:
data = {'token': token, 'user_id': user_id}
identifier = random.getrandbits(32)
key = get_apns_key(identifier)
redis_client.hmset(key, data)
redis_client.expire(key, expiry)
self.frame.add_item(token, payload, identifier, expiry, priority)
def send_push_notifications_multiple(notifications):
"""
Sends multiple push notifications to the Apple Push Notification
service (APNs) in a single connection.
Params:
notifications (list): A list containing dictionary objects with the
parameters that should be passed to the APNs.
Returns:
int: the number of bytes sent to the APNs
"""
frame = Frame()
apns = _get_apns_connection()
expiry = time.time() + (len(notifications) * 5)
priority = 10
for index, notification in enumerate(notifications, 1):
frame.add_item(
notification.pop('token'),
Payload(alert=notification.pop('alert'),
sound=notification.pop('sound', 'default'),
badge=notification.pop('badge', 1),
custom=notification), index, expiry, priority)
return apns.gateway_server.write(frame.get_frame())
def save(self, *args, **kwargs):
super(EmergencySchedule, self).save(*args, **kwargs)
if not self.is_booked:
if self.dentist.dentistprofile.device_token:
apns = APNs(use_sandbox=False,
cert_file=settings.APN_CERT_LOCATION,
key_file=settings.APN_KEY_LOCATION)
# Send a notification
token_hex = self.dentist.dentistprofile.device_token.all(
)[0].token
alert_message = 'Un RDV est disponible le %s a %s.' % (
self.date.strftime('%b %d,%Y'),
self.time.strftime('%H:%M'))
payload = Payload(alert=alert_message,
sound="default",
badge=1)
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
for patient in UserProfile.objects.filter(
dentist=self.dentist):
frame.add_item(patient.device_token.all()[0].token,
payload, identifier, expiry, priority)
notification = Notification(message=alert_message,
user=patient.user)
notification.save()
apns.gateway_server.send_notification_multiple(frame)
def test_add_frame_item():
global has_called_check_method
has_called_check_method = False
# assert_called_once_with of Mock Class failes to compare Payload object.
# So here created custom check method for parameter checking
def check_add_item_args(token, payload, identifier, expiry, priority):
default_expiry = int(time.time()) + (60 * 60)
eq_(token, dummy_token)
eq_(payload.alert, 'Hey')
eq_(payload.badge, None)
eq_(payload.sound, None)
eq_(payload.custom, {})
eq_(payload.content_available, False)
eq_(identifier, 123)
eq_(priority, 10, 'priority should set default value when skipped')
eq_(expiry, default_expiry,
'expiry should set default value when skipped')
global has_called_check_method
has_called_check_method = True
worker = SendWorkerThread(**dummy_setting)
worker.count = 123
frame = Frame()
frame.add_item = check_add_item_args
worker.add_frame_item(frame, 'myapp', dummy_token, {'alert': 'Hey'})
ok_(has_called_check_method)
def send_applicable_pushes(self, pushes):
payloads_and_tokens = [] # [(payload, token)]
for push in pushes:
for recip in push.recipients:
if '.' in recip:
token, service = recip.split('.', 1)
if service == self.name:
pl = Payload(alert=push.text, sound='default', badge=1)
payloads_and_tokens.append((pl, token))
if len(payloads_and_tokens):
prefix = 'dev' if self.is_sandbox() else 'prod'
apns = APNs(use_sandbox=self.is_sandbox(),
cert_file=prefix + '-cert.pem',
key_file=prefix + '-key.pem',
enhanced=True)
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
for payload, token in payloads_and_tokens:
frame.add_item(token, payload, identifier, expiry, priority)
apns.gateway_server.send_notification_multiple(frame)
for (token, failed_time) in apns.feedback_server.items():
print failed_time
print 'no f*****g feedback'
def send_expert_requests(self, user, approx_call_time, price_per_min,
max_wait, experts):
frame = Frame()
for expert in experts:
frame = self.add_expert_request(
user, approx_call_time, price_per_min, max_wait, expert, frame
)
if frame.notification_data:
self.send_notifications(frame)
def send_notification_with_payload(self, message, payload_dict):
if self.device_token_list:
apns = APNs(use_sandbox=True, cert_file=self.cert_path, key_file=self.key_path)
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
payload = Payload(alert=message, sound="default", badge=1, custom=payload_dict)
for device_token in self.device_token_list:
frame.add_item(device_token, payload, identifier, expiry, priority)
apns.gateway_server.send_notification_multiple(frame)
def massNotification(tokens, message):
apns = APNs(use_sandbox=True,
cert_file='certificates/certificate.pem',
key_file='certificates/npkey.pem')
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
payload = Payload(alert=message,
sound="default",
badge=1,
mutable_content=True)
for i in tokens:
frame.add_item(i, payload, identifier, expiry, priority)
apns.gateway_server.send_notification_multiple(frame)
return "Success"
def send_message_ios(tokens, alert_message, link_url):
cert = '/home/webuser/webapps/tigaserver/CertificatMosquito_prod.pem'
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
apns = APNs(use_sandbox=True, cert_file=cert)
for single_token in tokens:
try:
unread_notifications = get_pending_messages(single_token)
except:
unread_notifications = 0
payload = Payload(alert=alert_message,
sound="default",
badge=unread_notifications)
frame.add_item(single_token, payload, identifier, expiry, priority)
apns.gateway_server.send_notification_multiple(frame)
def update_wallets_states(force_update=False):
wallets = get_wallets_from_db()
addresses = [wallet['address'] for wallet in wallets]
address_to_device_token = {
wallet['address']: wallet['device_token']
for wallet in wallets
}
device_token_to_address = {
wallet['device_token']: wallet['address']
for wallet in wallets
}
addresses_unspent_outputs = return_unspent_outputs(addresses)
frame = Frame()
frame_empty = True
expiry = time.time() + config.EXPIRY
priority = config.PRIORITY
for address, utxos in addresses_unspent_outputs.items():
previous_state_of_address = redis.get(address)
current_state_of_address = gen_hash_for_dict(utxos)
print(address, previous_state_of_address, current_state_of_address)
if force_update or (current_state_of_address !=
previous_state_of_address):
print('Sending...')
for unspent_output in addresses_unspent_outputs[address]:
frame_empty = False
payload = Payload(alert=None,
sound=None,
custom={'data': json.dumps(unspent_output)},
badge=1,
content_available=not force_update)
frame.add_item(token_hex=address_to_device_token[address],
payload=payload,
identifier=1,
expiry=expiry,
priority=priority)
redis.set(address, current_state_of_address)
if not frame_empty:
try:
config.apns.gateway_server.send_notification_multiple(frame)
except requests.exceptions.SSLError as e:
print(e)
time.sleep(1)
config.apns = create_apn_service(cert_file=config.CERT_FILE,
key_file=config.KEY_FILE)
def testFrame(self):
identifier = 1
expiry = 3600
token_hex = 'b5bb9d8014a0f9b1d61e21e796d78dccdf1352f23cd32812f4850b878ae4944c'
payload = Payload(alert="Hello World!", sound="default", badge=4)
priority = 10
frame = Frame()
frame.add_item(token_hex, payload, identifier, expiry, priority)
f = (
'\x02\x00\x00\x00t\x01\x00 \xb5\xbb\x9d\x80\x14\xa0\xf9\xb1\xd6\x1e!'
'\xe7\x96\xd7\x8d\xcc\xdf\x13R\xf2<\xd3(\x12\xf4\x85\x0b\x87\x8a\xe4\x94L'
'\x02\x00<{"aps":{"sound":"default","badge":4,"alert":"Hello World!"}}'
'\x03\x00\x04\x00\x00\x00\x01\x04\x00\x04\x00\x00\x0e\x10\x05\x00\x01\n'
)
self.assertEqual(f, str(frame))
def send_push_notification(message,
sound_type="default",
cert_file_path='/home/ubuntu/pemfiles/cert.pem',
key_file_path='/home/ubuntu/pemfiles/comb.pem'):
apns = APNs(use_sandbox=True, cert_file=cert_file_path)
#key_file=key_file_path)
# Dummy hex
token_hex = '7ffdd1583899067942754f9afe2a575aa64f5ab3147834b9250a837f538f3097'
payload = Payload(alert=message, sound=sound_type, badge=1)
apns.gateway_server.send_notification(token_hex, payload)
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
frame.add_item(token_hex, payload, identifier, expiry, priority)
apns.gateway_server.send_notification_multiple(frame)
def sendNotification(token, message, timeout):
apns = APNs(use_sandbox=False, cert_file='cert.pem', key_file='key.pem')
frame = Frame()
identifier = random.getrandbits(32)
priority = 10
payload = {
"aps": {
"alert": message,
"sound": "default",
"identifier": identifier
}
}
#Payload(alert=message, sound="default", custom = {"identifier":identifier})
frame.add_item(token, payload, identifier, timeout, priority)
apns.gateway_server.send_notification_multiple(frame)
return identifier
#there'll be more stuff here, I promise
def send_batch(self):
if len(self.queue) > 0:
self.log.debug('Apns batch size: {0}'.format(len(self.queue)))
frame = Frame()
while len(self.queue) > 0:
notification = self.queue.pop()
notification['status'] = const.NOTIFICATION_SUCCESS
self.sent_queue[notification['sending_id']] = notification
data = self.create_message(notification)
if data:
frame.add_item(token_hex=data['token'],
payload=data['payload'],
identifier=data['identifier'],
expiry=data['expiry'],
priority=data['priority'])
# batch (frame) prepared, send it
self.apns.gateway_server.send_notification_multiple(frame)
def send_push_background(tokens, text, badge, data, content_available):
apns = APNs(use_sandbox=False,
cert_file='static/JukeboxBetaPush.pem',
key_file='static/JukeboxBetaPush.pem')
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
for device_token in tokens:
sound = None
if text:
sound = "default"
if not data:
data = {}
payload = Payload(alert=text,
sound=sound,
badge=badge,
custom=data,
content_available=content_available)
frame.add_item(device_token, payload, identifier, expiry, priority)
apns.gateway_server.send_notification_multiple(frame)
def test_frame_content():
worker = SendWorkerThread(**dummy_setting)
frame = Frame()
ok_(len(frame.frame_data) == 0)
worker.add_frame_item(frame,
'myapp',
dummy_token, {'alert': 'hello'},
expiry=None,
priority=10)
hex_frame = b2a_hex(str(frame.frame_data))
# Notification command
eq_('02', hex_frame[0:2])
# Frame length
eq_('00000051', hex_frame[2:10])
# Item ID:1 Device Token
eq_('01', hex_frame[10:12])
# Token Length
eq_('0020', hex_frame[12:16])
# Token
eq_(dummy_token, hex_frame[16:80])
def test_add_frame_item_with_full_args():
global has_called_check_method
has_called_check_method = False
# assert_called_once_with of Mock Class failes to compare Payload object.
# So here created custom check method for parameter checking
def check_add_item_args(token, payload, identifier, expiry, priority):
eq_(token, dummy_token)
eq_(payload.alert, 'Wow')
eq_(payload.badge, 50)
eq_(payload.sound, 'bell')
eq_(payload.custom, {'foo': 'bar'})
eq_(payload.content_available, True)
eq_(identifier, 1)
eq_(priority, 5)
eq_(expiry, 0)
global has_called_check_method
has_called_check_method = True
worker = SendWorkerThread(**dummy_setting)
worker.count = 1
frame = Frame()
frame.add_item = check_add_item_args
worker.add_frame_item(frame,
'myapp',
dummy_token, {
'alert': 'Wow',
'badge': 50,
'sound': 'bell',
'custom': {
'foo': 'bar'
},
'content_available': True,
},
expiry=0,
priority=5)
ok_(has_called_check_method)
def do_send_sms(sendDeviceStringList):
apns = APNs(use_sandbox=APNS_USE_SANDBOX,
cert_file=APNS_CERT_FILE,
key_file=APNS_KEY_FILE)
frame = Frame()
identifier = 1
expiry = time.time() + 3600 * 4
priority = 10
for info in sendDeviceStringList:
device_id = info['device_id']
alert = info['alert']
badge = info['badge']
payload = Payload(alert=alert, sound="default", badge=badge)
frame.add_item(device_id, payload, identifier, expiry, priority)
# DO SEND!
t1 = time.time()
apns.gateway_server.send_notification_multiple(frame)
t2 = time.time()
print "Sending %s notifications, using seconds = %s" % (
len(sendDeviceStringList), int(t2 - t1))
def execute(device_token_lists, notification):
if notification.is_production:
pem_file_name = ProductFileModel.objects.all()[0].production_file_name
apns = APNs(use_sandbox=False,
cert_file=PEM_FILE_DIR + pem_file_name,
enhanced=True)
else:
pem_file_name = DevelopFileModel.objects.all()[0].development_file_name
apns = APNs(use_sandbox=True,
cert_file=PEM_FILE_DIR + pem_file_name,
enhanced=True)
token_hex = []
for token in device_token_lists:
token_hex.append(token)
json_data = ''
if notification.json != '':
json_data = json.loads(notification.json)
payload = Payload(alert=notification.message,
sound=notification.sound,
badge=notification.badge,
custom=json_data)
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
for token in token_hex:
frame.add_item(token, payload, identifier, expiry, priority)
apns.gateway_server.send_notification_multiple(frame)
notification.is_sent = True
notification.status = 1
notification.save()
def make_push(self, request, queryset):
from apns import APNs, Frame, Payload
import time
wrapper = {}
frames = {}
for msg in queryset:
if msg.sent:
continue
if msg.device.development:
pem = msg.app.cert_dev
else:
pem = msg.app.cert_dist
key = "%d_%d" % (msg.app.pk, msg.device.development)
if not wrapper.has_key(key):
wrapper[key] = APNs(cert_file="/var/www/cert/%s" % pem, use_sandbox=msg.device.development)
frames[key] = Frame()
#wrapper = APNSNotificationWrapper("/home/mrgaolei/%s" % pem, msg.device.development)
custom = {}
# property
for ppt in msg.property_set.all():
custom[ppt.argkey] = ppt.argvalue
payload = Payload(alert = msg.alert, sound = msg.sound, badge = int(msg.badge), custom = custom, category = msg.category)
frames[key].add_item(msg.device.devtoken, payload, msg.pk, time.time()+3600, 10)
# property
# for ppt in msg.property_set.all():
#message.appendProperty(APNSProperty(str(ppt.argkey), str(ppt.argvalue)))
#message.appendProperty(APNSProperty(ppt.argkey.encode( "UTF-8" ), ppt.argvalue.encode( "UTF-8" )))
#wrapper[key].append(message)
#if wrapper.notify():
msg.sent = True
msg.save()
keys = wrapper.keys()
for key in keys:
wrapper[key].gateway_server.send_notification_multiple(frames[key])
def main(self):
frame = Frame()
try:
item_count = 0
while item_count < 500:
if item_count == 0:
# First time
# Wait here by blocking get
item = self.task_queue.get(True, self.TASK_QUEUE_TIMEOUT)
else:
item = self.task_queue.get(False)
item_count += 1
self.count += 1
self.store_item(self.count, item)
self.add_frame_item(frame, **item)
except Queue.Empty:
if item_count == 0:
raise QueueWaitTimeout()
if len(frame.frame_data) > 0:
self.send(frame)
self.check_error()
def apns_notification(tokens_hex, message):
apns = APNs(use_sandbox=True, cert_file='cert.pem', key_file='key.pem')
"""
# Send a notification
token_hex = 'b5bb9d8014a0f9b1d61e21e796d78dccdf1352f23cd32812f4850b87'
payload = Payload(alert="Hello World!", sound="default", badge=1)
apns.gateway_server.send_notification(token_hex, payload)
"""
# Send multiple notifications in a single transmission
# tokens_hex = []
payload = Payload(alert=message, sound="default", badge=1)
frame = Frame()
identifier = 1
expiry = time.time() + 3600
priority = 10
for token in tokens_hex:
frame.add_item(token, payload, identifier, expiry, priority)
apns.gateway_server.send_notification_multiple(frame)
def send_message(users, cert_file, key_file, sandbox=False, **data):
if not isinstance(users, list):
users = [users]
messaging_ids = [user.messaging_id for user in users \
if user.messaging_id is not None]
if not messaging_ids:
logging.debug('No messaging ids founds')
return
logging.debug('Using messaging sandbox: %s' % sandbox)
apns = APNs(
use_sandbox=sandbox,
cert_file=cert_file,
key_file=key_file,
)
payload = Payload(**data)
if len(users) == 1:
logging.debug('Sending message to: %s' % messaging_ids[0])
apns.gateway_server.send_notification(messaging_ids[0], payload)
else:
# Send multiple notifications in a single transmission
frame = Frame()
# used for reporting errors (in send_notification_multiple())
identifier = 1
# APNs stores notification until this time
expiry = time.time() + 3600
# 10=send immediately, 5=send at time that conserves device power
priority = 10
for messaging_id in messaging_ids:
frame.add_item(messaging_id, payload, identifier, expiry, priority)
logging.debug('Sending message to multiple users')
apns.gateway_server.send_notification_multiple(frame)
def __init__(self,
user,
tokens,
alert=None,
badge=None,
sound=None,
category=None,
**kwargs):
self.frame = Frame()
self.tokens = tokens
expiry = time.time() + 24 * 3600
priority = 10
payload = Payload(alert=alert,
badge=badge,
sound=sound,
category=category,
custom=kwargs)
for token in tokens:
data = {'token': token, 'user': user}
identifier = generate_random_token(32)
key = get_apns_key(identifier)
redis_client.hmset(key, data)
redis_client.expire(key, expiry)
self.frame.add_item(token, payload, identifier, expiry, priority)
import requests
from apns import APNs, Payload, Frame
import json
import random
import time
r = requests.get(
'https://rehabtracker.med.uvm.edu/Restful/getPushNotifications.php')
noteList = json.loads(r.text)
apns = APNs(use_sandbox=False,
cert_file='rehabDepCer.pem',
key_file='rehabDepKey.pem',
enhanced=True)
delivered = []
frame = Frame()
for note in noteList:
payload = Payload(alert=note['Message'], sound="default", badge=0)
identifier = random.getrandbits(32)
priority = 10
expiry = time.time() + 86400
print(note['UDID'])
frame.add_item(note['UDID'], payload, identifier, expiry, priority)
delivered.append(note['pmkPushID'])
apns.gateway_server.send_notification_multiple(frame)
postJson = json.dumps({"pushed": delivered})
POST = requests.post(
'https://rehabtracker.med.uvm.edu/Restful/getPushNotifications.php',
data=postJson)
print(POST.status_code)
