def update_card(): print('start update card') users = User.objects.all() for user in users: if user.card_drawer_of_next_day != '10102347454878415': user.update(card_drawer=None, draw_card_status='undraw') user.card_drawer = user.card_drawer_of_next_day user.card_drawer_of_next_day = None user.save() # send push notification print('send notification') try: user_list = User.objects.all() for user in user_list: if user.card_drawer != '10102347454878415': if user.device.ios != '': custom_payload = {'type': 'card'} payload = Payload(alert='已經有新的卡片囉!', sound="default", badge=1, custom=custom_payload) client = APNsClient(APNS_CERT, use_sandbox=USE_SANDBOX, use_alternative_port=False) client.send_notification(user.device.ios, payload, APNS_TOPIC) print('succeed') except Exception as e: print(e)
def _push(self, _apns, _body, _user_config): _ios_token = _user_config.get("device_ios_token") if _ios_token == None or len(_ios_token) == 0: return _user_language = _user_config.get("user_language") or "en_US" _title = push_title(_body.get("mt"), _body.get("ms"), _body.get("bo"), _user_language) _sound = None if not _user_config.get("user_silence_notification"): _sound = "beep.wav" _count = _user_config.get("unacked_notification_count") _m = {"alert": _title, "sound": _sound, "badge": _count} from apns2.client import APNsClient from apns2.payload import Payload _dev = _user_config.get("is_development") _client = APNsClient(_apns.get("combination_pem"), use_sandbox=False, use_alternative_port=False) if _dev != None and _dev == True: _client = APNsClient(_apns.get("combination_pem"), use_sandbox=True, use_alternative_port=False) _payload = Payload(**_m) _client.send_notification(_ios_token, _payload) return
def test_send_notification_failure_410(): with patch("apns2.credentials.CertificateCredentials.create_connection" ) as create_connection_mock: http_client_mock = MagicMock() http_client_mock.post.return_value = Response(status_code=410, json={ "reason": "BadDeviceToken", "timestamp": time.time() }) create_connection_mock.return_value = http_client_mock client = APNsClient(CertificateCredentials("test/mycert.pem")) exception_raised = False try: client.send_notification( token_hex=TOKEN, notification=Payload(alert="Test alert"), topic=TOPIC, ) except BadDeviceToken: exception_raised = True http_client_mock.post.assert_called_once() assert exception_raised is True
def send_Notification( message, key): token_hex = 'e4d3e8cb6e8c29d0dd6af4926e698c69632e2a8965cd17d66ed2d0cdd7869269' payload = Payload(alert="Hello World!", sound="default", badge=1) topic = 'ASU.SeatsFinderBot' client = APNsClient(key, use_sandbox=True, use_alternative_port=False) client.send_notification(token_hex, payload, topic)
def send_Notification(self, message, key, device_id): token_hex = device_id payload = Payload(alert=message, sound="default", badge=1) topic = 'ASU.SeatsFinderBot' client = APNsClient(key, use_sandbox=False, use_alternative_port=False) client.send_notification(token_hex, payload, topic)
class NotificationService: def __init__(self): self.topic = 'com.epage.QuietMind' self.token_map = {} self.client = APNsClient(DEV_CERT_FILE, use_sandbox=True, use_alternative_port=False) # self.apns = APNs(use_sandbox=True, cert_file=CERT_FILE, key_file=KEY_FILE) # self.apns = APNs(use_sandbox=True, cert_file=CERT_FILE, enhanced=True) # self.client = APNSClient(certificate=CERT_FILE, # default_error_timeout=10, # default_expiration_offset=2592000, # default_batch_size=100, # default_retries=3) def register_token(self, userId, token): print('register notification token', userId, token) self.token_map[userId] = token def get_token(self, userId): if userId in self.token_map: return self.token_map[userId] return DEFAULT_TOKEN def send_notification(self, userId, message="Hello World!"): token_hex = self.get_token(userId) payload = Payload(alert=message, sound="default", badge=1) print(payload.__dict__) topic = 'com.epage.QuietMind' self.client = APNsClient(DEV_CERT_FILE, use_sandbox=True, use_alternative_port=False) self.client.send_notification(token_hex, payload, topic)
def send_ios(self, story, user, usersub): if not self.is_ios: return tokens = MUserNotificationTokens.get_tokens_for_user(self.user_id) # To update APNS: # 1. Create certificate signing requeswt in Keychain Access # 2. Upload to https://developer.apple.com/account/resources/certificates/list # 3. Download to secrets/certificates/ios/aps.cer # 4. Open in Keychain Access and export as aps.p12 # 4. Export private key as aps_key.p12 WITH A PASSPHRASE (removed later) # 5. openssl pkcs12 -in aps.p12 -out aps.pem -nodes -clcerts -nokeys # 6. openssl pkcs12 -clcerts -nokeys -out aps.pem -in aps.p12 # 7. cat aps.pem aps_key.noenc.pem > aps.p12.pem # 8. Verify: openssl s_client -connect gateway.push.apple.com:2195 -cert aps.p12.pem # 9. Deploy: aps -l work -t apns,repo,celery apns = APNsClient( '/srv/newsblur/config/certificates/aps.p12.pem', use_sandbox=tokens.use_sandbox ) notification_title_only = is_true(user.profile.preference_value('notification_title_only')) title, subtitle, body = self.title_and_body(story, usersub, notification_title_only) image_url = None if len(story['image_urls']): image_url = story['image_urls'][0] # print image_url confirmed_ios_tokens = [] for token in tokens.ios_tokens: logging.user( user, '~BMStory notification by iOS: ~FY~SB%s~SN~BM~FY/~SB%s' % (story['story_title'][:50], usersub.feed.feed_title[:50]), ) payload = Payload( alert={'title': title, 'subtitle': subtitle, 'body': body}, category="STORY_CATEGORY", mutable_content=True, custom={ 'story_hash': story['story_hash'], 'story_feed_id': story['story_feed_id'], 'image_url': image_url, }, ) try: apns.send_notification(token, payload, topic="com.newsblur.NewsBlur") except (BadDeviceToken, Unregistered): logging.user(user, '~BMiOS token expired: ~FR~SB%s' % (token[:50])) else: confirmed_ios_tokens.append(token) if settings.DEBUG: logging.user( user, '~BMiOS token good: ~FB~SB%s / %s' % (token[:50], len(confirmed_ios_tokens)), ) if len(confirmed_ios_tokens) < len(tokens.ios_tokens): tokens.ios_tokens = confirmed_ios_tokens tokens.save()
def send_message(self, message=None, **kwargs): """Send push message to registered devices.""" from apns2.client import APNsClient from apns2.payload import Payload from apns2.errors import Unregistered apns = APNsClient( self.certificate, use_sandbox=self.sandbox, use_alternative_port=False) device_state = kwargs.get(ATTR_TARGET) message_data = kwargs.get(ATTR_DATA) if message_data is None: message_data = {} if isinstance(message, str): rendered_message = message elif isinstance(message, template_helper.Template): rendered_message = message.render() else: rendered_message = "" payload = Payload( alert=rendered_message, badge=message_data.get("badge"), sound=message_data.get("sound"), category=message_data.get("category"), custom=message_data.get("custom", {}), content_available=message_data.get("content_available", False)) device_update = False for push_id, device in self.devices.items(): if not device.disabled: state = None if device.tracking_device_id is not None: state = self.device_states.get( device.full_tracking_device_id) if device_state is None or state == str(device_state): try: apns.send_notification( push_id, payload, topic=self.topic) except Unregistered: logging.error( "Device %s has unregistered.", push_id) device_update = True device.disable() if device_update: self.write_devices() return True
def send_apn(push_token: str): ''' Sends an empty APN to the given device push_token ''' payload = Payload() client = APNsClient(config.PASS_TYPE_CERTIFICATE_PATH, use_sandbox=False, use_alternative_port=False, password=config.PEM_PASSWORD) client.send_notification(push_token, payload, config.PASS_TYPE_IDENTIFIER)
def send_message(self, message=None, **kwargs): """Send push message to registered devices.""" from apns2.client import APNsClient from apns2.payload import Payload from apns2.errors import Unregistered apns = APNsClient(self.certificate, use_sandbox=self.sandbox, use_alternative_port=False) device_state = kwargs.get(ATTR_TARGET) message_data = kwargs.get(ATTR_DATA) if message_data is None: message_data = {} if isinstance(message, str): rendered_message = message elif isinstance(message, template_helper.Template): rendered_message = message.render() else: rendered_message = "" payload = Payload( alert=rendered_message, badge=message_data.get("badge"), sound=message_data.get("sound"), category=message_data.get("category"), custom=message_data.get("custom", {}), content_available=message_data.get("content_available", False), ) device_update = False for push_id, device in self.devices.items(): if not device.disabled: state = None if device.tracking_device_id is not None: state = self.device_states.get( device.full_tracking_device_id) if device_state is None or state == str(device_state): try: apns.send_notification(push_id, payload, topic=self.topic) except Unregistered: logging.error("Device %s has unregistered", push_id) device_update = True device.disable() if device_update: self.write_devices() return True
def send_notification(apns_token, message, sender, channel, badge=1, network=None, intent=None, private=False): global apns_client if apns_client is None: apns_client = APNsClient(os.path.join(DIRECTORY, 'production.pem'), heartbeat_period=30) query = None if channel: query = channel elif sender: query = sender if message and intent == 'ACTION': message = '* %s' % (message) sound = None alert = {} if message or private: sound = 'default' user_info = {} if query and network: user_info['n'] = network user_info['q'] = query if sender: alert['title'] = sender if channel: alert['subtitle'] = channel if private: alert['loc-key'] = 'INPUT_MESSAGE_PLACEHOLDER' alert['body'] = 'Message' elif message: alert['body'] = message payload = Payload(alert=alert, sound=sound, badge=badge, custom=user_info) apns_client.connect() try: apns_client.send_notification(apns_token, payload, TOPIC) except (BadDeviceToken, Unregistered) as e: with database.transaction(): try: device = Device.get(Device.apns_token == apns_token) device.delete_instance(recursive=True) except Device.DoesNotExist: return
def push(request): #fcm_device = GCMDevice.objects.create(registration_id="e--N1a4DuTg:APA91bGrwQnf8h5o3UHrVPx3PTkTVumOEfHP5dfAdvFDuBA2h6QZVG0MYuQtGRH21nvdnb44sThudENkAeEtrmBND3g1gv2A0IlLW4ZMsCGl_AsBDWCR4FJm6s57pf-PPz5BGTkIWCbw", cloud_message_type="FCM", user='******') #device = GCMDevice.objects.get(registration_id="e--N1a4DuTg:APA91bGrwQnf8h5o3UHrVPx3PTkTVumOEfHP5dfAdvFDuBA2h6QZVG0MYuQtGRH21nvdnb44sThudENkAeEtrmBND3g1gv2A0IlLW4ZMsCGl_AsBDWCR4FJm6s57pf-PPz5BGTkIWCbw") token_hex = '106ececed6c5985efb2afd75618a41120086e7e93488315dc03ccd9eff0be257' payload = Payload(alert="Hello World!", sound="default", badge=1) topic = 'com.example.App' client = APNsClient( 'https://s3-us-west-1.amazonaws.com/blake-deets/aps_development.cer', use_sandbox=False, use_alternative_port=False) client.send_notification(token_hex, payload, topic)
def sendpushnotification(DeviceToken, OrderID, StoreID, dev_flag, Message): #send the push notification custom = {'launchURL': 'x-com.petco.wrapper.sim://launch'} payload = Payload(alert=Message, sound="popcorn.wav", badge=0, custom=custom) topic = 'com.petco.notifications' IOS_Client = APNsClient('./Apple_Certificate/server1.pem', use_sandbox=dev_flag, use_alternative_port=False) IOS_Client.send_notification(DeviceToken, payload, topic) return True
class Notifier: def __init__(self): self.client = APNsClient(cert, use_sandbox=sandbox, use_alternative_port=False) def send(self, token, message, count, isSilent): if isSilent: payload = Payload(content_available=True, badge=count) else: # TODO create custom sound (more so on client) payload = Payload(alert=message, sound="default", badge=count) topic = 'com.bfichter.KookMachine' self.client.send_notification(token, payload, topic)
def send_ios(self, story, user, usersub): if not self.is_ios: return tokens = MUserNotificationTokens.get_tokens_for_user(self.user_id) apns = APNsClient('/srv/newsblur/config/certificates/aps.p12.pem', use_sandbox=tokens.use_sandbox) notification_title_only = is_true( user.profile.preference_value('notification_title_only')) title, subtitle, body = self.title_and_body(story, usersub, notification_title_only) image_url = None if len(story['image_urls']): image_url = story['image_urls'][0] # print image_url confirmed_ios_tokens = [] for token in tokens.ios_tokens: logging.user( user, '~BMStory notification by iOS: ~FY~SB%s~SN~BM~FY/~SB%s' % (story['story_title'][:50], usersub.feed.feed_title[:50])) payload = Payload(alert={ 'title': title, 'subtitle': subtitle, 'body': body }, category="STORY_CATEGORY", mutable_content=True, custom={ 'story_hash': story['story_hash'], 'story_feed_id': story['story_feed_id'], 'image_url': image_url, }) try: apns.send_notification(token, payload, topic="com.newsblur.NewsBlur") except (BadDeviceToken, Unregistered): logging.user(user, '~BMiOS token expired: ~FR~SB%s' % (token[:50])) else: confirmed_ios_tokens.append(token) if settings.DEBUG: logging.user( user, '~BMiOS token good: ~FB~SB%s / %s' % (token[:50], len(confirmed_ios_tokens))) if len(confirmed_ios_tokens) < len(tokens.ios_tokens): tokens.ios_tokens = confirmed_ios_tokens tokens.save()
def send_apn_notification(message, endpoint): token = endpoint.device_token payload = Payload(alert=message, sound="default", badge=1) if settings.APNS_CERT_FILE: # allows for reuse of apns client and reuse of connections # TODO: handles errors by fcm client global apns_client if not apns_client: apns_client = APNsClient(settings.APNS_CERT_FILE, password=settings.APNS_CERT_PASSWORD, use_sandbox=settings.DEBUG, use_alternative_port=False) topic = settings.APNS_APP_BUNDLE_ID apns_client.send_notification(token, payload, topic)
def send_push(self, title, body): connects = UserConnectionField.objects.find_type_connection_by_user( self.user, UserConnectionField.APNS_TYPE) client = APNsClient(settings.APNS_KEY_LOCATION, use_sandbox=settings.APNS_SENDBOX, use_alternative_port=False) payload = Payload(alert=PayloadAlert(title=title, body=body), sound="default", badge=1) for connect in connects: client.send_notification(token_hex=connect.value, notification=payload, topic=settings.APNS_BUNDLE_ID)
def push(category, title, body, device_token, params): payload = Payload(alert=PayloadAlert(title=None if title == '' else title, body=body), sound='1107', badge=int(params['badge']) if 'badge' in params else 0, category=category, mutable_content=True, custom=params) client = APNsClient(CERT_PATH) try: client.send_notification(device_token, payload, 'me.fin.bark') return '' except APNsException as e: return str(e)
def test_send_notification_success(): with patch("apns2.credentials.CertificateCredentials.create_connection" ) as create_connection_mock: http_client_mock = MagicMock() http_client_mock.post.return_value = Mock(status_code=200) create_connection_mock.return_value = http_client_mock client = APNsClient(CertificateCredentials("test/mycert.pem")) client.send_notification( token_hex=TOKEN, notification=Payload(alert="Test alert"), topic=TOPIC, ) http_client_mock.post.assert_called_once()
def send_notification(user_id, st_code, condition, curr_value): logger.info("User to notify: %s" % user_id) notif_flag = False # Get the real name of the station station_name = Station.query.filter(Station.code == st_code).one().name logger.info("Station to be notified about: %s" % station_name) # Get the notification token from the users table token_hex = User.query.filter(User.device_id == user_id).one().notif_token logger.info("Notification token: %s" % token_hex) # Get the key, key path and team_id from the constants file and build # token credentials object token_credentials = TokenCredentials(auth_key_path=NOTIF_AUTH_KEY_PATH, auth_key_id=NOTIF_AUTH_KEY_ID, team_id=NOTIF_TEAM_ID) # Compose the text notif_text = notif_texts_format[condition['dimension']][condition['quantifier']] % \ (station_name,condition['value'],float(curr_value)) logger.info("Sending notification: %s" % notif_text) # Compose the dict with the station code and station name custom_data = {'station_code': st_code, 'station_name': station_name} topic = NOTIF_TOPIC payload = Payload(alert=notif_text, sound="default", badge=0, custom=custom_data) client = APNsClient(credentials=token_credentials, use_sandbox=True) try: #apns.gateway_server.send_notification(token_hex, payload,identifier=identifier) client.send_notification(token_hex, payload, topic) mark_as_notified(user_id, st_code, condition) logger.info("Notification sent!") notif_flag = True except: logger.error("Error sending notification!!") print("ERROR ENVIANDO NOTIFICACION") return notif_flag
class NotificationPusher(object): def __init__(self, topic, auth_key_path, auth_key_id, team_id, use_sandbox=False): self.topic = topic self.client = APNsClient(TokenCredentials(auth_key_path, auth_key_id, team_id), use_sandbox=use_sandbox, use_alternative_port=False) def push(self, token_hex, beverage): payload = Payload(alert=f"{beverage} is ready!", sound="default", badge=1) self.client.send_notification(token_hex, payload, self.topic)
class SMS: """ Push SMS via APNs """ def __init__(self, text: str): self.__client = APNsClient(credentials=credentials, use_sandbox=use_sandbox) self.__payload = Payload(alert=text) def send(self, identifier: str) -> int: identifier = ID.parse(identifier=identifier) device = Device(identifier) tokens = device.tokens if tokens is None: print('Device token not found, failed to push message: %s' % self.__payload.alert) return 0 count = 0 for token in tokens: self.__client.send_notification(token_hex=token, notification=self.__payload) count += 1 print('Message has been sent to %d device(s)' % count) return count
def push_notification(self, credentials, push_sandbox, pass_type_id, push_token): payload = Payload() try: client = APNsClient( credentials, use_sandbox=push_sandbox, use_alternative_port=False, ) client.send_notification( push_token, payload, pass_type_id, ) except SSLError as e: logger.error("django_walletpass SSLError: %s", e) except StreamResetError as e: logger.error("django_walletpass StreamResetError. Bad cert or token? %s", e) # Errors should never pass silently. except Exception as e: # Unless explicitly silenced. logger.error("django_walletpass uncaught error %s", e)
def send_pushs(followers, ng_group, ng_news): father = ng_news while father.father != '': try: father = NGNews.objects.get(message_id=father.father) except NGNews.DoesNotExists: break data = { 'event_type': 'NEW_NEWS', 'host': ng_group.host.host, 'newsgroup_id': ng_group.id, 'newsgroup': ng_group.name, 'news_id': ng_news.id, 'news_uid': ng_news.message_id, 'subject': ng_news.subject, 'author': ng_news.email_from, 'creation_date': ng_news.date.strftime("%Y-%m-%dT%H:%M:%S%z") } # Google Android devices android_devices = GCMDevice.objects.filter(user__in=followers, active=1) for android_device in android_devices: log = Log() log.type = 'N' log.group = ng_group log.user = android_device.user log.description = "Android notification (registration_id=%s) (subject=%s)"\ % (android_device.registration_id, ng_news.subject) log.save() android_devices.send_message(json.dumps(data)) # Apple iOS devices ios_devices = APNSDevice.objects.filter(user__in=followers, active=1) apns_cert_prod = PUSH_NOTIFICATIONS_SETTINGS['APNS_CERTIFICATE'] apns_cert_dev = PUSH_NOTIFICATIONS_SETTINGS['APNS_CERTIFICATE_DEV'] apns_cert_password = PUSH_NOTIFICATIONS_SETTINGS[ 'APNS_CERTIFICATE_PASSWORD'] topic = PUSH_NOTIFICATIONS_SETTINGS['APNS_TOPIC'] payload = CustomPayload(group=data['newsgroup'], title=data['subject'], contents=ng_news.contents, sound="default", badge=1, news_id=father.id, author=ng_news.email_from) client_prod = APNsClient(apns_cert_prod, use_sandbox=False, use_alternative_port=False, password=apns_cert_password) client_dev = APNsClient(apns_cert_dev, use_sandbox=True, use_alternative_port=False, password=apns_cert_password) for ios_device in ios_devices: token = ios_device.registration_id success = False try: client_prod.send_notification(token, payload, topic) success = True except: try: client_dev.send_notification(token, payload, topic) success = True except Exception as e: print(str(e)) pass #ios_device.active = False #ios_device.save() if success: log = Log() log.type = 'N' log.group = ng_group log.user = ios_device.user log.description = "iOs notification (registration_id=%s) (subject=%s)" \ % (token, ng_news.subject) log.save()
def receive(self, text_data): # get parameter text_data_json = json.loads(text_data) self.scope['user'] = text_data_json['user_id'] content = text_data_json['content'] time = text_data_json['time'] # save message to DB message = Message.objects.get(message_id=self.scope['message_id']) id = len(message.messages) + 1 new_message_content = MessageContent(id=id, user_id=self.scope['user'], time=time, content=content) message.update(add_to_set__messages=new_message_content) # Send Push Notifications if message.user_id.user_1 == self.scope['user']: receiver_user = message.user_id.user_2 receiver_user_notification = message.notification.user_2 else: receiver_user = message.user_id.user_1 receiver_user_notification = message.notification.user_1 send_user = User.objects.get(user_id=self.scope['user']) receiver_user = User.objects.get(user_id=receiver_user) receiver_user_ios_device_id = receiver_user.device.ios try: if receiver_user_ios_device_id != '' and receiver_user_notification: notification_content = send_user.english_name + ': ' + content custom_payload = { 'type': 'message', 'message_id': self.scope['message_id'], 'user_id': send_user.user_id, 'english_name': send_user.english_name, 'chinese_name': send_user.chinese_name, 'photo': send_user.photo } payload = Payload(alert=notification_content, sound="default", badge=1, custom=custom_payload) client = APNsClient(APNS_CERT, use_sandbox=USE_SANDBOX, use_alternative_port=False) client.send_notification(receiver_user_ios_device_id, payload, APNS_TOPIC) except Exception as e: print(e) # Send WebSocket async_to_sync(self.channel_layer.group_send)( self.scope['room_name'], { "type": "chat.message", "text": json.dumps({ "content_id": id, "user_id": self.scope['user'], "time": time, "content": content, }), }, )
def _send_via_apn(self, apns_token, data): payload = Payload(alert=data, sound="default", badge=1) client = APNsClient(self.external_config['ios_apns_cert'], use_sandbox=self.external_config['is_sandbox'], use_alternative_port=False) client.send_notification(apns_token, payload, 'io.wazo.songbird.voip')
class ApplePushNotificationService: class Delegate(ABC): """ APNs Delegate ~~~~~~~~~~~~~ """ @abstractmethod def device_tokens(self, identifier: ID) -> List[str]: """ get device tokens in hex format """ pass def __init__(self, credentials, use_sandbox=False, use_alternative_port=False, proto=None, json_encoder=None, password=None, proxy_host=None, proxy_port=None): super().__init__() # APNs client parameters self.credentials = credentials self.use_sandbox = use_sandbox self.use_alternative_port = use_alternative_port self.proto = proto self.json_encoder = json_encoder self.password = password self.proxy_host = proxy_host self.proxy_port = proxy_port self.client = None # APNsClient # topic self.topic = 'chat.dim.sechat' # delegate to get device token self.__delegate: weakref.ReferenceType = None # APNs Delegate # counting offline messages self.badge_table = {} def debug(self, msg: str): Log.debug('%s >\t%s' % (self.__class__.__name__, msg)) def info(self, msg: str): Log.info('%s >\t%s' % (self.__class__.__name__, msg)) def warning(self, msg: str): Log.warning('%s >\t%s' % (self.__class__.__name__, msg)) def error(self, msg: str): Log.error('%s >\t%s' % (self.__class__.__name__, msg)) @property def delegate(self) -> Delegate: if self.__delegate is not None: return self.__delegate() @delegate.setter def delegate(self, value: Delegate): self.__delegate = weakref.ref(value) def badge(self, identifier: ID) -> int: num = self.badge_table.get(identifier) if num is None: num = 1 else: num = num + 1 self.badge_table[identifier] = num return num def clear_badge(self, identifier: ID) -> bool: if identifier in self.badge_table: self.badge_table.pop(identifier) return True def connect(self) -> bool: try: self.client = APNsClient(credentials=self.credentials, use_sandbox=self.use_sandbox, use_alternative_port=self.use_alternative_port, proto=self.proto, json_encoder=self.json_encoder, password=self.password, proxy_host=self.proxy_host, proxy_port=self.proxy_port) return True except IOError as error: self.error('failed to connect apple server: %s' % error) return False def send_notification(self, token_hex, notification, topic=None, priority=NotificationPriority.Immediate, expiration=None, collapse_id=None) -> int: if self.client is None and self.connect() is False: self.error('cannot connect apple server, message dropped: %s' % notification) return -503 # Service Unavailable try: if topic is None: topic = self.topic # push to apple server self.client.send_notification(token_hex=token_hex, notification=notification, topic=topic, priority=priority, expiration=expiration, collapse_id=collapse_id) return 200 # OK except IOError as error: self.error('connection lost: %s' % error) return -408 # Request Timeout except APNsException as error: self.error('failed to push notification: %s, error %s' % (notification, error)) return -400 # Bad Request def push(self, identifier: ID, message: str) -> bool: # 1. check tokens = self.delegate.device_tokens(identifier=identifier) if tokens is None: self.error('cannot get device token for user %s' % identifier) return False # 2. send badge = self.badge(identifier) payload = Payload(alert=message, badge=badge, sound='default') success = 0 for token in tokens: self.debug('sending notification %s to user %s with token %s' % (message, identifier, token)) # first try result = self.send_notification(token_hex=token, notification=payload) if result == -503: # Service Unavailable # connection failed break elif result == -408: # Request Timeout self.error('Broken pipe? try to reconnect again!') # reset APNs client self.client = None # try again result = self.send_notification(token_hex=token, notification=payload) if result == 200: # OK success = success + 1 if success > 0: self.info('sending notification success:%d badge=%d, %s' % (success, badge, identifier)) return True
from apns2.client import APNsClient from apns2.payload import Payload CERT_FILE = "./apns-dev.pem" KEY_FILE = "./apns-dev-key-noenc.pem" token_hex = 'f7ca3b57016e6882fe11b7253e16b2068bdee0f119800b4271456bb04e896149' payload = Payload(alert="Hello World!", sound="default", badge=1) print(payload.__dict__) topic = 'com.epage.QuietMind' client = APNsClient(CERT_FILE, use_sandbox=True, use_alternative_port=False) client.send_notification(token_hex, payload, topic)
def draw_card(): userList = list() users = User.objects.all() users.update(card_drawer=None, friend_invitation=None, is_draw_card=False) for user in users: # remove Thomas if user.user_id != '10102347454878415': userList.append(user) # need to handle this issue removed_user = '' if len(userList) % 2 != 0: print('remove one user') removed_user = random.SystemRandom().choice(userList) print(removed_user) for user_index in range(len(userList)): if userList[user_index].user_id == removed_user.user_id: lastUser = userList.pop(user_index) print(lastUser) break # give a card to removed user find_new_card = True while find_new_card: removed_user_card = random.SystemRandom().choice(userList) removed_user_instance = User.objects.get( user_id=removed_user.user_id) removed_user_friends = removed_user_instance.friends is_friend = False for friend in removed_user_friends: if friend.user_id == removed_user_card.user_id: is_friend = True break if not is_friend: removed_user_instance.update( card_drawer=removed_user_card.user_id) find_new_card = False # assign removed user id to 'removed_user_id' if there is removed user if removed_user != '': removed_user_id = removed_user.user_id else: removed_user_id = '' loopTime = len(userList) / 2 - 1 count = 0 while count < loopTime: print(len(userList)) pairUser = random.SystemRandom().sample(userList, 2) print(pairUser) firstUserId = str(pairUser[0]) secondUserId = str(pairUser[1]) firstUser = User.objects.get(user_id=firstUserId) friends = list(firstUser.friends) is_friend = False for friend in friends: if friend.user_id == secondUserId: print("these two users are already friends.") is_friend = True break if is_friend: continue firstUser.update(card_drawer=secondUserId) secondUser = User.objects.get(user_id=secondUserId) secondUser.update(card_drawer=firstUserId) for user in pairUser: userList.remove(user) print(len(userList)) count += 1 # match last two users: # need to check if last two users are already friends print('start to match last two users') is_friend = False first_user = User.objects.get(user_id=str(userList[0])) second_user = User.objects.get(user_id=str(userList[1])) first_user_friends = first_user.friends second_user_friends = second_user.friends for friend in first_user_friends: print('first user:'******'friend id:', friend.user_id) print('second user:'******'is_friend:', is_friend) if is_friend: check_list = list() check_list.append(str(first_user)) check_list.append(str(second_user)) for friend in first_user_friends: check_list.append(str(friend.user_id)) for friend in second_user_friends: if not str(friend.user_id) in check_list: check_list.append(str(friend.user_id)) selected_user_list = list() users = User.objects.all() removed_user_list = [ str(first_user), str(second_user), removed_user_id, '10102347454878415' ] for user in users: if user.user_id not in removed_user_list and user.card_drawer != '': selected_user_list.append(user) print(selected_user_list) first_selected_user = None second_selected_user = None check_first_selected_user = False check_second_selected_user = False count_rematch_time = 0 while not check_first_selected_user or not check_second_selected_user: count_rematch_time += 1 print("check if the selected users are in the check list.") check_first_selected_user = False check_second_selected_user = False first_selected_user = random.SystemRandom().choice( selected_user_list) second_selected_user_id = User.objects.get( user_id=str(first_selected_user)).card_drawer second_selected_user = User.objects.get( user_id=str(second_selected_user_id)) if not str(first_selected_user.user_id) in check_list: check_first_selected_user = True print("first selected user is not in the check list.") if not str(second_selected_user.user_id) in check_list: check_second_selected_user = True print("second selected user is not in the check list.") if count_rematch_time > 20: print('restart') return draw_card() first_user.update(card_drawer=str(first_selected_user.user_id)) first_selected_user.update(card_drawer=str(first_user.user_id)) second_user.update(card_drawer=str(second_selected_user.user_id)) second_selected_user.update(card_drawer=str(second_user.user_id)) print("first: ", first_user) print("first select: :", first_selected_user) print("second: ", second_user) print("second select: :", second_selected_user) print("match last two users with other two users.") else: print("match last two users.") second_user.update(card_drawer=str(first_user)) first_user.update(card_drawer=str(second_user)) print('start to send notifications') try: user_list = User.objects.all() for user in user_list: if user.device.ios != '': # print(user.device.ios) custom_payload = {'type': 'card'} payload = Payload(alert='已經有新的卡片囉!', sound="default", badge=1, custom=custom_payload) client = APNsClient(APNS_CERT, use_sandbox=USE_SANDBOX, use_alternative_port=False) client.send_notification(user.device.ios, payload, APNS_TOPIC) # me = User.objects.get(user_id='10210833777112798') # if me.device.ios != '': # custome_payload = { # 'type': 'card' # } # payload = Payload(alert='已經有新的卡片囉!', sound="default", badge=1, custom=custome_payload) # client = APNsClient(APNS_CERT, use_sandbox=USE_SANDBOX, use_alternative_port=False) # client.send_notification(me.device.ios, payload, APNS_TOPIC) except Exception as e: print(e) print('finished')
time_start = time.time() db = pymysql.connect(config.SQL_SERVER_ADDRESS, config.SQL_SERVER_USER, config.SQL_SERVER_PASSWORD, config.SQL_SERVER_DATABASE) cursor = db.cursor() cursor.execute("SELECT * FROM apns") results = list(set(cursor.fetchall())) invalid_list = [] for row in results: token_id = row[0] token = row[1] try: client.send_notification(token, Payload(content_available=1), TOPIC) time.sleep(0.08) except BadDeviceToken: invalid_list.append(token_id) except Unregistered: invalid_list.append(token_id) for token_id in invalid_list: cursor.execute("DELETE FROM apns WHERE id = %d" % int(token_id)) db.commit() db.close() f = open("log", "a") f.write(str(datetime.datetime.now())) f.write("\nNotification Pushed. %d devices. %d devices are removed.\n" % (len(results), len(invalid_list))) f.write("Time Used = %ds\n" % (time.time() - time_start))
def watch_rooms(docs, changes, read_time): for change in changes: try: if (change.type.name == "ADDED") or \ (change.type.name == "MODIFIED") or \ (change.type.name == "REMOVED"): room = change.document.to_dict() if (change.type.name == "REMOVED"): room["users"] = [] if (change.document.id not in last_rooms): last_rooms[change.document.id] = {"users": []} last_room = last_rooms[change.document.id] isPrivate = room.get("isPrivate", False) for userid in room["users"]: db.collection(USER_COLLECTION).document(userid).update( {"inPrivate": isPrivate}) if userid not in last_room["users"]: db.collection(EVENT_COLLECTION).document().set({ "type": ROOM_JOIN_EVENT_TYPE, "user": userid, "room": change.document.id, "isPrivate": isPrivate, "time": firestore.SERVER_TIMESTAMP }) notifData = { "room": change.document.id, "inCall": json.dumps(room["users"]) } payload = Payload(alert="", custom=notifData) if (userid in last_users) and \ ("controllingUUID" in last_users[userid]) and \ (last_users[userid]["controllingUUID"].startswith("mobile:")) and \ (not last_users[userid]["active"]): # TODO slight race here where user is inaccessible after # disconnecting from websocket but before we realize it print(last_users[userid]) if "APNSPushToken" in last_users[userid]: # TODO check if on mobile isDev = ("APNSDev" in last_users[userid]) and \ (last_users[userid]["APNSDev"]) apns_client = APNsClient('BLANK', use_sandbox=isDev) apns_client.send_notification( last_users[userid]["APNSPushToken"], payload, "BLANK") if "FCMToken" in last_users[userid]: message = messaging.Message( data=notifData, token=last_users[userid]['FCMToken']) response = messaging.send(message) print( 'Sent call notification to {}, response {}' .format(userid, response)) for userid in last_room["users"]: if userid not in room["users"]: db.collection(USER_COLLECTION).document(userid).update( {"inPrivate": False}) db.collection(EVENT_COLLECTION).document().set({ "type": ROOM_EXIT_EVENT_TYPE, "user": userid, "room": change.document.id, "isPrivate": isPrivate, "time": firestore.SERVER_TIMESTAMP }) if len(room["users"]) == 1: last_user = list(room["users"].keys())[0] db.collection(USER_COLLECTION).document(last_user).update( {"roomId": ""}) change.document.reference.delete() last_rooms[change.document.id] = room except Exception as e: print(traceback.print_exc())
def _run_train(self, pid, category, network_model, task_id, output_model_dir, num_epochs, finetune_last_layer, push_message, final_train, queue): result = False try: finish, output_graph, quantized_graph, output_labels, global_step_count = controller.run_training( pid, category, task_id, self.upload_folder, self.unknown_folder, self.pretrained_folder, self.tensorflow_folder, output_model_dir, network_model, num_epochs, finetune_last_layer) if finish: # update model status controller.update_model_path(pid, category, output_graph, quantized_graph, output_labels, network_model) if final_train: train_status = controller.TrainingStatus.final_trained else: train_status = controller.TrainingStatus.basic_trained if finetune_last_layer: train_mode = controller.TrainingMode.finetune else: train_mode = controller.TrainingMode.full_train controller.update_model_status( pid, category, train_status, train_mode=train_mode, global_step_count=global_step_count) # send push message to client if push_message: bundle_ids, device_tokens = controller.get_train_wait_devices( task_id) for idx in range(len(bundle_ids)): bundle_id = bundle_ids[idx] device_token = device_tokens[idx] if bundle_id in self.apns_settings: apns_key_file = self.apns_settings[bundle_id][ "APNS_KEY_FILE"] apns_use_sandbox = self.apns_settings[bundle_id][ "APNS_USE_SANDBOX"] if os.path.exists(apns_key_file): print("device waited for training : " + device_token) if final_train: push_message = "Training finished completely." else: push_message = "Initial training completed." payload = Payload(alert=push_message, sound="default", badge=1) client = APNsClient( apns_key_file, use_sandbox=apns_use_sandbox, use_alternative_port=False) client.send_notification(device_token, payload, topic=bundle_id) print("sent push message for device " + device_token) else: print("APNS key does not exists : " + apns_key_file) else: print("Bundle ID does not exists in settings : " + bundle_id) result = True else: controller.delete_train_task(pid, category, task_id) controller.delete_train_wait_devices(task_id) except Exception: controller.update_model_status(pid, category, controller.TrainingStatus.error) controller.delete_train_task(pid, category, task_id) controller.delete_train_wait_devices(task_id) traceback.print_exc() queue.put(result) return queue.put(result) return