def send_visible_notification(self, token_map, title, message, json_data, dev=False): if len(token_map) == 0: logging.info("len(token_map) == 0, early return to save api calls") return # convert tokens if necessary fcm_token_map = self.convert_to_fcm_if_necessary(token_map, dev) push_service = FCMNotification(api_key=self.server_auth_token) data_message = { "data": json_data, "payload": json_data } # Send android and iOS messages separately because they have slightly # different formats # https://github.com/e-mission/e-mission-server/issues/564#issuecomment-360720598 android_response = push_service.notify_multiple_devices(registration_ids=fcm_token_map["android"], data_message=data_message) ios_response = push_service.notify_multiple_devices(registration_ids=fcm_token_map["ios"], message_body = message, message_title = title, data_message=data_message) combo_response = {"ios": ios_response, "android": android_response} logging.debug(combo_response) return combo_response
def push_notification(self, data): ret = {'is_success': True, 'error': ''} now_user = self.request.user to_list = [] if self.is_super_admin: all_users_id = list(OSFUser.objects.all().values_list('pk', flat=True)) all_tokens = RdmFcmDevice.objects.filter(user_id__in=all_users_id).distinct().values_list( 'device_token', flat=True) to_list = list(all_tokens) elif self.is_admin: now_institutions_id = list(now_user.affiliated_institutions.all().values_list('pk', flat=True)) all_institution_users_id = list(OSFUser.objects.filter(affiliated_institutions__in=now_institutions_id).distinct().values_list( 'pk', flat=True)) all_institution_tokens = RdmFcmDevice.objects.filter(user_id__in=all_institution_users_id).distinct().values_list( 'device_token', flat=True) to_list = list(all_institution_tokens) else: ret['is_success'] = False return ret try: api_key = FCM_SETTINGS.get('FCM_SERVER_KEY') FCMNotification(api_key=api_key) push_service = FCMNotification(api_key=api_key) registration_ids = list(set(to_list)) # Remove duplicates message_title = data['title'] message_body = data['body'] push_service.notify_multiple_devices(registration_ids=registration_ids, message_title=message_title, message_body=message_body) except Exception as e: ret['is_success'] = False ret['error'] = 'Push notification error: ' + str(e) finally: return ret
def send_visible_notification(self, token_list, title, message, json_data, dev=False): if len(token_list) == 0: logging.info( "len(token_list) == 0, early return to save api calls") return # convert tokens if necessary fcm_token_map = self.convert_to_fcm_if_necessary(token_list, dev) push_service = FCMNotification(api_key=self.server_auth_token) data_message = {"data": json_data, "payload": json_data} # Send android and iOS messages separately because they have slightly # different formats # https://github.com/e-mission/e-mission-server/issues/564#issuecomment-360720598 android_response = push_service.notify_multiple_devices( registration_ids=fcm_token_map["android"], data_message=data_message) ios_response = push_service.notify_multiple_devices( registration_ids=fcm_token_map["ios"], message_body=message, message_title=title, data_message=data_message) combo_response = {"ios": ios_response, "android": android_response} logging.debug(combo_response) return combo_response
def _notify(self, message): res = super(MailChannel, self)._notify(message) if self.env['ir.config_parameter'].sudo().get_param( 'mail_notify.is_fcm_enabled'): push_service = FCMNotification( api_key=self.env['ir.config_parameter'].sudo().get_param( 'mail_notify.fcm_server_key')) base_url = self.env['ir.config_parameter'].sudo().get_param( 'web.base.url') or '' message_values = message.message_format()[0] icon = message.author_id and ( base_url + ('/web/image/res.partner/' + str(message.author_id.id) + '/image_small')) or (base_url + '/mail/static/src/img/smiley/avatar.jpg') web_tokens = (message.sudo().mapped( 'channel_ids.channel_partner_ids.user_ids') - message.sudo().author_id.user_ids ).mapped('token_ids').filtered( lambda t: t.type == 'web').mapped('token') action_id = self.env.ref('mail.action_discuss').id #badge = ('/web/image/res.company/%s/badge' % str(self.env.user.company_id.id)) if self.env.user.company_id.badge else '/web/static/src/img/favicon.ico' if web_tokens: push_service.notify_multiple_devices( registration_ids=web_tokens, message_title=message_values['author_id'][1], message_icon=icon, click_action=base_url + '/web?#action=' + str(action_id) + '&active_id=' + str(self.id), #badge = base_url + badge, message_body=html2text(message_values['body'])) return res
def notify_webcam(): try: content = json.loads(request.data) users = [] lock = Locks.query.get(content['lockId']) username = lock.username owner = Users.query.get(username) push_service = FCMNotification( api_key= 'AAAASi2VHpQ:APA91bGqzWABHfFOtzeuwc1AvIjGDCtXS90JkEErLxICILPrx81ScnzZv_AhE7um20rzOYTe28Hkhy_cF3Xj5ZqxucVaYRwkDGFIiUO3_RRbvfsr1kwsZDHdzZZJTCiPpu9whij3Puoo' ) message_title = 'ACCESS' message_icon = 'notification_icon' message_body = 'Someone wishes to access ' + lock.alias push_service.notify_multiple_devices(registration_ids=owner.appIds, message_title=message_title, message_body=message_body, message_icon=message_icon, low_priority=False) for user in Acl.query.filter_by(lockId=content['lockId']): appIds = Users.query.get(user.username).appIds push_service.notify_multiple_devices(registration_ids=appIds, message_title=message_title, message_body=message_body, message_icon=message_icon, low_priority=False) return 'true' except Exception as e: return str(e)
def send_message(self, message_title, message_body, data_message=None): from pyfcm import FCMNotification push_service = FCMNotification(api_key=settings.NOTICATION_KEY) extra_notification_kwargs = { 'android_channel_id': 'ONTECX-DEFAULT' } if data_message is not None: return push_service.notify_multiple_devices(registration_id=self.registration_id, message_title=message_title, message_body=message_body, data_message=data_message, extra_notification_kwargs=extra_notification_kwargs) return push_service.notify_multiple_devices(registration_id=self.registration_id, message_title=message_title, message_body=message_body, data_message=data_message, extra_notification_kwargs=extra_notification_kwargs)
def push_to_fcm_multy(device_token, gcm_key, title=None, message=None, data=None, sound=None, badge=None): fcm_push_service = FCMNotification(api_key=gcm_key) fcm_push_service.notify_multiple_devices( registration_ids=device_token, message_title=title, message_body=message, data_message=data, sound=sound, badge=badge )
def handle(self, *args, **kwargs): data_message = dict(type="url", message="hello", title="hell", url="url", click_action="FLUTTER_NOTIFICATION_CLICK") push_service = FCMNotification(api_key=settings.FCM_API_KEY) registration_ids = Device.objects.all().values_list("registration_id", flat=True) registration_ids = list(set(list(registration_ids))) push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=data_message['type'], message_body=data_message["message"], data_message=data_message) self.stdout.write('Successfully send ..')
class FcmPi: def __init__(self): # Here holds essential information, # Firebase server key and device token. self._server_key = '' self._device_token = [] with open(cf.FCM_SERVER_FILE, "r", encoding="utf-8") as file: self._server_key = file.readline() with open(cf.FCM_DEVICE_FILE, "r", encoding="utf-8") as device_file: # Read file. list = device_file.readlines() # Read api key # if there are multiple keys, then something is wrong. if len(list) is 0: print('\tNo device token found.') else: # print('\tServer API key found.') for user in list: self._device_token.append(str(user).rstrip('\n')) # Remove \n # # Server self.fcm_service = FCMNotification(api_key=self._server_key) loggerd.log('FCM service initiated.', 'fcm') print('\tFCM service initiated.') # Parameter: String, String, Action(String, mostly URL) # Returns: - # Author: acoustikue(SukJoon Oh) def notifyMultipleDevice(self, m_title, m_body, action='', kwargs=None): print('\tSent push to: ' + self._device_token[0][0:15]) print('\t... and more.') #for token in self._device_token: # print('\t' + token[0:19] + '...') # send push! self.fcm_service.notify_multiple_devices(registration_ids=self._device_token, \ message_title=m_title, message_body=m_body, click_action=action \ , extra_notification_kwargs=kwargs) pass
def send_fcm_notification(title="", body="", data=None, users=None): """ sends fcm notification to a single or multiple user device :param title: title of the notification message :param body: body of the notification :param data: any data to be sent :param users: list of user ids :return: True/False """ if users: push_service = FCMNotification(api_key=settings.FCM_API_KEY) try: if data: if isinstance(users, list): registration_ids = [ devices.registration_id for devices in UserDevice.objects.filter( used_id__in=users) ] push_service.multiple_devices_data_message( registration_ids=registration_ids, data_message=data) else: registration_id = UserDevice.objects.get( user_id=users).registration_id push_service.single_device_data_message( registration_id=registration_id, data_message=data) else: if isinstance(users, list): registration_ids = [ devices.registration_id for devices in UserDevice.objects.filter( user_id__in=users) ] push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=title, message_body=body) else: registration_id = UserDevice.objects.get( user_id=users).registration_id push_service.notify_single_device( registration_id=registration_id, message_title=title, message_body=body) return True except: return False else: return False
def notify(self): push = FCMNotification(api_key="") self.db.query("select * from tokens") results = self.db.store_result() results = results.fetch_row(maxrows=0) l = [] for x in results: l.append(x[0]) title = 'Crime Alert!' body = 'Crime!' msg = {'location': 'Bookstore', 'case_id': '170214-0692'} push.notify_multiple_devices(registration_ids=l, message_title=title, message_body=body, data_message=msg)
def send_sale_alarm(station, sale_type, sale_name, sale_price, sale_link): user_dic = {} user_dic = get_user_toke(station, sale_type) for key, value in user_dic.items(): print(key, value) for key, value in user_dic.items(): if value == 1: push_service = FCMNotification( api_key= "AAAADgTMcII:APA91bFMVVBZB7bOM8BqocEGTJToANS9sB4Da0ODqG4RTfndoUapWBye8ASi9d3-rHUCkq4BvabFLgSqBfdyqrxtWCqZj3lYSYXpsFB-Szvo4gEgh9cExF24Puvr3I9rQ7r-H-pWMMQ0" ) push_tokens = [str(key)] print(str(key)) han_station = find_station_location(station) han_type = translate_type(sale_type) message_title = str(han_station) + " " + str(han_type) + " 매물 등록" message_body = "매물명: " + str(sale_name) + "/ 가격: " + str( sale_price) result = push_service.notify_multiple_devices( registration_ids=push_tokens, message_title=message_title, message_body=message_body) print(result)
def handle(self, *args, **options): push_service = FCMNotification(api_key=settings.PDK_FIREBASE_API_KEY) event_definition = DataGeneratorDefinition.definition_for_identifier( 'pdk-app-event') tokens = {} for point in DataPoint.objects.filter( generator_definition=event_definition, secondary_identifier='pdk-firebase-token').order_by('created'): properties = point.fetch_properties() tokens[point.source] = properties['event_details']['token'] token_list = [] for source, token in tokens.iteritems(): # pylint: disable=unused-variable if (token in token_list) is False: token_list.append(token) message = {'operation': 'nudge', 'source': 'passive-data-kit'} result = push_service.notify_multiple_devices( registration_ids=token_list, data_message=message) if settings.DEBUG: print 'Firebase nudge result: ' + str(result) print '(Update settings.DEBUG to suppress...)'
def post(self,request): if not request.data._mutable: request.data._mutable = True request.data['user']=User.objects.filter(id=request.user.id)[0].id request.data['team']=TeamInfo.objects.filter(team_number=request.data['team'])[0].id request.data._mutable = False serializer = MessagingSerializer(data=request.data) print(request.data) push_service = FCMNotification(api_key="AIzaSyD8v3e4a3v-rcasU3Mh0KKkPaflm1dW1J4") if serializer.is_valid(): print(serializer.validated_data) serializer.save(user=request.user) if not serializer.data['message_conf']: devices = Notifications.objects.all()#.exclude(user=request.user) UNCOMMMENT THIS IN FUTURE registration_ids=[] for i in devices: registration_ids.append(i.device_id) result = push_service.notify_multiple_devices(registration_ids=registration_ids, message_title=serializer.data['message_heading'], message_body=serializer.data['message_body']) print(result) return Response(serializer.data, status=201) return Response(serializer.errors, status=400) else: request.data['user']=request.user serializer = MessagingSerializer(data=request.data) if serializer.is_valid(): serializer.save() return Response(serializer.data, status=201) return Response(serializer.errors, status=400)
def data_push(self, device, registration_id, data_message): push_service = FCMNotification(api_key=config('SERVER_KEY')) if device == "single": result = push_service.notify_single_device(registration_id=registration_id, data_message=data_message) else: result = push_service.notify_multiple_devices(registration_ids=registration_id, data_message=data_message) print(result)
def notify(): # Send to single device. from pyfcm import FCMNotification push_service = FCMNotification(api_key="<api-key>") # Your api-key can be gotten from: https://console.firebase.google.com/project/<project-name>/settings/cloudmessaging registration_id = "<device registration_id>" message_title = "Uber update" message_body = "Hi john, your customized news for today is ready" result = push_service.notify_single_device(registration_id=registration_id, message_title=message_title, message_body=message_body) # Send to multiple devices by passing a list of ids. registration_ids = ["<device registration_id 1>", "<device registration_id 2>", ...] message_title = "Uber update" message_body = "Hope you're having fun this weekend, don't forget to check today's news" result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body) print(result)
def sendNotification(username, post): flist = Follows.query.filter_by(follows=username) nameret = user_details.query.filter_by(username=username).first() name = nameret.fullname registration_ids = [] usernames = [] for i in flist: dataret = user_token.query.filter_by(username=i.username).first() registration_ids.append(dataret.token) usernames.append(dataret.username) push_service = FCMNotification( api_key= "AAAAFXEDMyw:APA91bHARuwO7X7Y5I_lLwkbEiQ3bCzt3TVS6awj6iqFolpd_YXMKKhevsoMsdx-cCWPkaXMR7iFuJB0X3TrVXqUcOgqSIfTO898PgWEsWZQrdZbDt8RILtgicYOS836jypqnMdAbsG4J170Fvj0tOdtB_USzhqj-g" ) message_title = "New Post from " + name message_body = post.desc result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body) print message_title print message_body print str(registration_ids) print str(usernames) print str(result)
def send_push_notification(self, user_tokens, subject: Subject): fcm_api_key = os.getenv("FCM_API_KEY") # print(fcm_api_key) push_service = FCMNotification(api_key=fcm_api_key) # OR initialize with proxies push_service = FCMNotification(api_key=fcm_api_key) # Your api-key can be gotten from: https://console.firebase.google.com/project/<project-name>/settings/cloudmessaging # registration_id = "cA53EyujqEHAr2VzhWi47M:APA91bGtXuVeilvlK7z3UrBTmRnBx7TRQphAm3_cjun6admjs_Apl2K34dNNC3Cgky35gxiCZ0akl9P3TFbzSUbPTTJK1aZhCwphjvh3194ksref_JKYdNNClrYq6EyCF3mz2f2kM1ja" # message_title = "rental alert" # message_body = "Hi john, your customized news for today is ready" # print("send notification") # result = push_service.notify_single_device(registration_id=registration_id, message_title=message_title, message_body=message_body) # Send to multiple devices by passing a list of ids. registration_ids = user_tokens temp = base64.b64decode(subject.name) name = temp.decode("UTF-8") message_title = f"{name}" message_body = f"{subject.location}/{subject.region}/{subject.location}/{subject.price}" data_message = {'subject_id': f'{subject.subject_id}'} result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body, data_message=data_message) print(f"push result: {result}")
class FirebasePopupNotifications(IObserver): def __init__(self, firebase_server_key: str): self.service = FCMNotification(api_key=firebase_server_key) def update(self, update_info: UpdateInfo): session = DBInstance.get_instance().new_session() channel = GameBasedChannelsManager.get_game_based_channel( session, update_info.steam_id) subs = UserManager.get_subscribes(channel) session.close() self.__notify_users(channel, subs, update_info) def __notify_users(self, channel: GameBasedChannel, users: Generator[User], update_info: UpdateInfo): ids: List[str] = [] for user in users: ids += user.firebase_tokens response = self.service.notify_multiple_devices( registration_ids=ids, message_title=f"NEW UPDATE IN {channel.name}", message_body=update_info.short_description) for message in response: if 'error' in message: logger.error(f"FCM ERROR {message}")
class Message(): def __init__(self, group_to_notify, message_title, message_body): self.push_service = FCMNotification( api_key= "AAAAYIooHik:APA91bF6utyDUSgqYX0MgZKhRM3-76kWvBYNXK6NY3HNKtM45shnt8JHbsx0x2XtpE2yXmEtH7MA6lR0M5e9BJuyJ5sDG1c8cjEwCpLZzZv93jyFUOQhofC1oOoMm6iWvfjRSuBU5_3r" ) self.message_title = message_title self.message_body = message_body self.notify_ids = self.fetch_group_members(group_to_notify) def fetch_group_members(self, group_id): members_ref = db.reference("/groups/" + group_id + "/members") users_ref = db.reference("/users") notify_ids = [ users_ref.child(x).child("notify_id").get() for x in members_ref.get().keys() ] print(notify_ids) return notify_ids def send(self): return self.push_service.notify_multiple_devices( registration_ids=self.notify_ids, message_title=self.message_title, message_body=self.message_body)
class PushMessage: def __init__(self, token_list, title, body=None, badge=None): self.token_list = token_list self.title = title self.body = body self.badge = badge registry = getUtility(IRegistry) self.push_service = FCMNotification( api_key=registry['infoporto.push_api_key']) self.push_locations = registry['infoporto.push_location'] or '/push/' def send(self): logger.info("Sending push to %s" % self.token_list) result = self.push_service.notify_multiple_devices( registration_ids=self.token_list, message_title=self.title, message_body=self.body) logger.debug(result) def queue(self): print self.push_locations container = api.content.get(path=self.push_locations) for token in self.token_list: obj = api.content.create(type='PushMessage', title=self.title, message=self.body, recipient=token, state='OUTGOING', container=container) logger.info("Push %s for %s added to queue" % (obj.id, token))
def sendgroupnotification(): push_service = FCMNotification( api_key= "AAAAYv7rBNM:APA91bEwGTAwNGMqqFnh_3YSrcbCFvcwXvxlJhdEumZQQ6RU7_PnBlbBZILJwWKEyXLOaKCgLUDXwMiPk8lx1ONWyzrcR1KI5fxLysyAgrgWsLPhPrFjsLYsEiV-rsD39OcMcwd_omvU_zIFI-ynM0j0_RKj0OgRqQ" ) masterids = request.form.getlist('masterid') manager = dbhelper.DBManager() tokens = [] for masterid in masterids: tokens.append(str(manager.getToken(masterid))) message_title = request.form.get("title") message_body = request.form.get("message") newNotif = dbhelper.Notification() newNotif.title = message_title newNotif.message = message_body newNotif.sendTimestamp = datetime.datetime.now() manager.addGroupNotification(masterids, newNotif) result = push_service.notify_multiple_devices(registration_ids=tokens, message_title=message_title, message_body=message_body) print(result) return "Notifcation sent successfully"
def push_procedure_to_devices(owner, procedure_id): # api_key from https://console.firebase.google.com/project/sanamobile-1f7b1/settings/general/ push_service = FCMNotification(api_key="FILL API KEY HERE") secret_key = os.urandom(32).encode('hex') PushEvent.objects.create(procedure_id=procedure_id, secret_key=secret_key) # create a data message data_message = { "type": "newProcedure", "procedureId": procedure_id, "secretKey": secret_key, "fetchUrl": "/api/procedures/{}/fetch?secret={}".format(procedure_id, secret_key), } registration_ids = Device.objects.all().values_list('registration_id', flat=True) registration_ids = [i.encode('ascii', 'ignore') for i in registration_ids] result = push_service.notify_multiple_devices( registration_ids=registration_ids, data_message=data_message)
def fcm_send_bulk_message(registration_ids, title=None, body=None, icon=None, data=None, sound=None, badge=None, low_priority=None, condition=None, time_to_live=None, click_action=None, collapse_key=None, **kwargs): api_key = SETTINGS.get("FCM_SERVER_KEY") push_service = FCMNotification(api_key=api_key) result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=title, message_body=body, message_icon=icon, data_message=data, sound=sound, badge=badge, collapse_key=collapse_key, low_priority=low_priority, condition=condition, time_to_live=time_to_live, click_action=click_action, **kwargs) # do not raise errors, pyfcm will raise exceptions if response status will # be anything but 200 return result
def send_notification_to_all(): api_key = '' if api_key != '': print('inside push notification') ids = User.objects.filter( is_active=True, is_superuser=False).values_list('device_token', flat=True) ids = list(ids) push_service = FCMNotification(api_key=api_key) registration_ids = ids message_title = "KishMalik Notification" message_body = 'Please check a new article added in the list' result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body) users = User.objects.filter(is_active=True, is_superuser=False) for u in users: un = UserNotification( user=u, notification=notification_msg, req_type='6', ) un.save() return True return False
def buy(): f = open("eur.txt", "r") eur = float(f.read()) - 0.5 f.close() print(str(eur) + "€ vorhanden!") f = open("eur.txt", "w") f.write("0") f.close() eth = eur / ethPrice print(str(eth) + " ETH gekauft!") push_service = FCMNotification( api_key= "AAAAOL_f7Vw:APA91bHx4r3FM3rH2RxU2JtjoMRMm8At-c9XGrUnxpp6BCHtQLup1uvjAzIifOBAMMqCDOi_Z0O6wgqYGMtVJdt4EUdVzBXiUmpP_kTJRWB_9TmJBTp2II3tELBvSBhQvxMZxxLYP_Xu" ) registration_ids = [ "dSvcsDop4ek:APA91bFcfxJak8NLbyxjpXavu3RLbf28jNLRRcAcTTN7_dzg-MS8rzN3uRsPvMgpmPNvpJCaRIFMOliUDX169uf3cH2V7isYYMa0F6Hn5VZRunVhz_ZJBUot5m9V2HotGtbBxtAULUvM" ] message_title = "ETH gekauft" message_body = str(eth) + " ETH vorhanden" result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body) f = open("eth.txt", "w") f.write(str(eth)) f.close()
def send_push_notification( ): # send a fcm push notification to all android devices from pyfcm import FCMNotification API_KEY = 'fcm api key here' push_service = FCMNotification(api_key=API_KEY) # parse list of fcmRegKeys with touchopen('/var/www/devices.json', 'r') as f: fcntl.lockf(f, fcntl.LOCK_EX) obj = json.load(f) registration_ids = [] for i in obj["devices"]: registration_ids.append(i["fcmRegKey"]) # Send to multiple devices by passing a list of ids. app.logger.info("regId size:%d", len(registration_ids)) message_title = "MySmartHome" message_body = "Check your home" result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body) print result
def sendNotification(string): push_service = FCMNotification(api_key="enter-key-here") # OR initialize with proxies #proxy_dict = { # "http" : "http://127.0.0.1", # "https" : "http://127.0.0.1", # } #push_service = FCMNotification(api_key="<api-key>", proxy_dict=proxy_dict) # Your api-key can be gotten from: https://console.firebase.google.com/project/<project-name>/settings/cloudmessaging registration_ids = ["enter-ids-here-separated-with-commas"] message_title = "Nowe zdjecie" message_body = string result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=message_title, message_body=message_body) # Send to multiple devices by passing a list of ids. # registration_ids = ["<device registration_id 1>", "<device registration_id 2>", ...] # message_title = "Uber update" # message_body = "Hope you're having fun this weekend, don't forget to check today's news" # result = push_service.notify_multiple_devices(registration_ids=registration_ids, message_title=message_title, message_body=message_body) print result
def send_silent_notification(self, token_list, json_data, dev=False): if len(token_list) == 0: logging.info( "len(token_list) == 0, early return to save api calls") return ios_raw_data = copy.copy(json_data) # multiplying by 10^6 gives us the maximum resolution possible while still # being not a float. Have to see if that is too big. # Hopefully we will never send a push notification a millisecond to a single phone ios_raw_data.update({"notId": int(time.time() * 10**6)}) ios_raw_data.update({"payload": ios_raw_data["notId"]}) push_service = FCMNotification(api_key=server_auth_token) FirebasePush.print_dev_flag_warning() # convert tokens if necessary fcm_token_list = self.convert_to_fcm_if_necessary(token_list) response = push_service.notify_multiple_devices( registration_ids=fcm_token_list, data_message=ios_raw_data, content_available=True) logging.debug(response) return response
def send_visible_notification(self, token_list, title, message, json_data, dev=False): if len(token_list) == 0: logging.info( "len(token_list) == 0, early return to save api calls") return FirebasePush.print_dev_flag_warning() # convert tokens if necessary fcm_token_list = self.convert_to_fcm_if_necessary(token_list) push_service = FCMNotification(api_key=server_auth_token) data_message = {"data": json_data, "payload": json_data} response = push_service.notify_multiple_devices( registration_ids=fcm_token_list, message_body=message, message_title=title, data_message=data_message) logging.debug(response) return response
def getNotifications(): push_service = FCMNotification(api_key="AIzaSyB1byDiSollNF32f7auagCdzRXWqcs8aAs") if(len(pdservice.getNotificationData())==0): return "No notifications available" else: j = pdservice.getNotificationData() message_title ="Shopping notification" message_body="You should buy these products by tomorrow : " + "\n" products_name="" device_registration_ids=[] message="" #print len(j) for registration_id,value in j.items(): device_registration_ids.append(registration_id) for i in range(0,len(value)): products_name = products_name + str(value[i]).title() + "\n" message = message_body + products_name + "\n" result = push_service.notify_multiple_devices(registration_ids=device_registration_ids, message_title=message_title, message_body=message) print result products_name="" message="" device_registration_ids=[] return "sucess"
def push_urls(crawler_id, crawler_name, changed_line, url_link ): #make push message for ios title_ios = str("구독중인 "+ crawler_name + " 이/가 변경되었습니다!") message_ios = str(changed_line) #make push message for android message_data_android = {'title': str(crawler_name + " Changed!"), 'body': str(changed_line), 'clickurl': str(url_link) } #shoot the crawler id to API server and receive the subscribe user as json type payload = {'crawler_id': crawler_id} received_json = requests.post(api_request_url, data=payload) #parse the json user data token_receive_data = received_json.json() for k in token_receive_data['data']: tokens.append(k['push_token']) for i in api_list: push_service = FCMNotification(api_key=i) result = None try: if i == api_list[0]: #which means push to android result = push_service.notify_multiple_devices(registration_ids=tokens, data_message=message_data_android) elif i == api_list[1]: #which means push to ios result = push_service.notify_multiple_devices(message_title=title_ios, message_body=message_ios,registration_ids=tokens, data_message={}) except Exception as e: print(e) print(str(result)) tokens.clear() return;
def send_silent_notification(self, token_map, json_data, dev=False): if len(token_map) == 0: logging.info("len(token_map) == 0, early return to save api calls") return ios_raw_data = copy.copy(json_data) # multiplying by 10^6 gives us the maximum resolution possible while still # being not a float. Have to see if that is too big. # Hopefully we will never send a push notification a millisecond to a single phone ios_raw_data.update({"notId": int(time.time() * 10**6)}) ios_raw_data.update({"payload": ios_raw_data["notId"]}) push_service = FCMNotification(api_key=self.server_auth_token) # convert tokens if necessary fcm_token_map = self.convert_to_fcm_if_necessary(token_map, dev) response = push_service.notify_multiple_devices(registration_ids=fcm_token_list, data_message=ios_raw_data, content_available=True) logging.debug(response) return response
#!/usr/bin/python # pip install pyfcm # ref: https://github.com/olucurious/PyFCM from pyfcm import FCMNotification from os import environ from pprint import PrettyPrinter # requirement: # export FCM_API_KEY and FCM_TOKENS in .profile api_key = environ["FCM_API_KEY"] device_tokens = environ['FCM_TOKENS'].split(";") print "using api_key=", api_key, "device_tokens=", device_tokens fcm = FCMNotification(api_key = api_key) pretty_printer = PrettyPrinter(indent=2) message_title = "FCM Message Title" message_body = "FCM Test Message" data_message = { "message": "FCM Test Message", "link": "https://jackcsk.me" } result = fcm.notify_multiple_devices(registration_ids = device_tokens, message_title = message_title, message_body = message_body, data_message = data_message) #result = fcm.multiple_devices_data_message(registration_ids = device_tokens, data_message = data_message) print "FCM Response:" pretty_printer.pprint(result)
if notification_count < 2: # Send to single device. push_service = FCMNotification(api_key="AIzaSyBl6il28Gs0OeQGdzF4FsjRuaZoT6C8r38") regs = database.notification.find() id = database.judgement.find() registration_ids = [] for reg in regs: registration_ids.append(reg['device_id']) message_title = header message_body = case_number result = push_service.notify_multiple_devices(registration_ids=registration_ids, message_title=message_title, message_body=json.loads(string)) print(string) print(result) notification_count = notification_count + 1 else: exit() """ # Send to multiple device. last_case = database.judgement.find().sort('_id',pymongo.DESCENDING).limit(1) for a in last_case: ida = a['_id'] category = a['category'] string = '{"id":"' + str(ida) + '","category":"' + str(category) + '"}'
def fcm_send_bulk_message( registration_ids, title=None, body=None, icon=None, data=None, sound=None, badge=None, low_priority=False, condition=None, time_to_live=None, click_action=None, collapse_key=None, delay_while_idle=False, restricted_package_name=None, dry_run=False, color=None, tag=None, body_loc_key=None, body_loc_args=None, title_loc_key=None, title_loc_args=None, content_available=None, extra_kwargs={}, api_key=None, json_encoder=None, **kwargs): """ Copied from https://github.com/olucurious/PyFCM/blob/master/pyfcm/fcm.py: Send push notification to a single device Args: registration_ids (list): FCM device registration IDs. body (str): Message string to display in the notification tray data (dict): Data message payload to send alone or with the notification message sound (str): The sound file name to play. Specify "Default" for device default sound. Keyword Args: collapse_key (str, optional): Identifier for a group of messages that can be collapsed so that only the last message gets sent when delivery can be resumed. Defaults to ``None``. delay_while_idle (bool, optional): If ``True`` indicates that the message should not be sent until the device becomes active. time_to_live (int, optional): How long (in seconds) the message should be kept in FCM storage if the device is offline. The maximum time to live supported is 4 weeks. Defaults to ``None`` which uses the FCM default of 4 weeks. low_priority (boolean, optional): Whether to send notification with the low priority flag. Defaults to ``False``. restricted_package_name (str, optional): Package name of the application where the registration IDs must match in order to receive the message. Defaults to ``None``. dry_run (bool, optional): If ``True`` no message will be sent but request will be tested. Returns: :tuple:`multicast_id(long), success(int), failure(int), canonical_ids(int), results(list)`: Response from FCM server. Raises: AuthenticationError: If :attr:`api_key` is not set or provided or there is an error authenticating the sender. FCMServerError: Internal server error or timeout error on Firebase cloud messaging server InvalidDataError: Invalid data provided InternalPackageError: JSON parsing error, mostly from changes in the response of FCM, create a new github issue to resolve it. """ if api_key is None: api_key = SETTINGS.get("FCM_SERVER_KEY") push_service = FCMNotification(api_key=api_key, json_encoder=json_encoder, ) result = push_service.notify_multiple_devices( registration_ids=registration_ids, message_title=title, message_body=body, message_icon=icon, data_message=data, sound=sound, badge=badge, collapse_key=collapse_key, low_priority=low_priority, condition=condition, time_to_live=time_to_live, click_action=click_action, delay_while_idle=delay_while_idle, restricted_package_name=restricted_package_name, dry_run=dry_run, color=color, tag=tag, body_loc_key=body_loc_key, body_loc_args=body_loc_args, title_loc_key=title_loc_key, title_loc_args=title_loc_args, content_available=content_available, extra_kwargs=extra_kwargs, **kwargs ) # do not raise errors, pyfcm will raise exceptions if response status will # be anything but 200 return result