def push_to_all(): headers = request.headers if 'Msg-Title' in headers.keys() and 'Msg-Body' in headers.keys(): members = db.Members.find({}) if members and members.count() > 0: for doc in members: if len(doc["subscription"]) > 0: data_message = { "title": headers['Msg-Body'], "body": headers['Msg-Body'], "admin_message": True } for sub in doc["subscription"]: try: webpush(sub, json.dumps(data_message), vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=VAPID_CLAIMS) except WebPushException as ex: print("subscription is offline") db.Members.find_one_and_update( { 'name': doc['name'], 'email': doc['email'] }, {"$pull": { "subscription": sub }}) return "sending push", 200 else: return "No Members", 400 else: return "Wrong Headers", 403
def push_notification(title, body, user_id): user_subscriptions = UserSubscription.objects.filter(user_id=user_id) for subscription in user_subscriptions: data = json.dumps({ 'title': title, 'body': body, }) try: webpush( subscription_info=json.loads(subscription.subscription), data=data, vapid_private_key='./private_key.pem', vapid_claims={ 'sub': 'mailto:[email protected]', } ) except WebPushException as ex: err_logger.error('Processed AccessError')('I can\'t do that: {}'.format(repr(ex))) err_logger.error('Processed AccessError')(ex) if ex.response and ex.response.json(): extra = ex.response.json() err_logger.error('Processed AccessError')('Remote service replied with a {}:{}, {}', extra.code, extra.errno, extra.message)
def test_send_vapid(self, mock_post): mock_post.return_value.status_code = 200 subscription_info = self._gen_subscription_info() data = "Mary had a little lamb" webpush( subscription_info=subscription_info, data=data, vapid_private_key=self.vapid_key, vapid_claims={"sub": "mailto:[email protected]"}, content_encoding="aesgcm" ) eq_(subscription_info.get('endpoint'), mock_post.call_args[0][0]) pheaders = mock_post.call_args[1].get('headers') eq_(pheaders.get('ttl'), '0') def repad(str): return str + "===="[:len(str) % 4] auth = json.loads( base64.urlsafe_b64decode( repad(pheaders['authorization'].split('.')[1]) ).decode('utf8') ) ok_(subscription_info.get('endpoint').startswith(auth['aud'])) ok_('WebPush' in pheaders.get('authorization')) ckey = pheaders.get('crypto-key') ok_('p256ecdsa=' in ckey) ok_('dh=' in ckey) eq_(pheaders.get('content-encoding'), 'aesgcm')
def deny_user(): headers = request.headers if 'Name' in headers.keys() and 'Email' in headers.keys(): member = db.awaitingMembers.find_one_and_delete({ 'name': headers['name'], 'email': headers['email'] }) if member: try: if member["subscription"]: data_message = { "title": "Approval denied!", "body": member["name"] + " , " + member["email"] + ", your registration has been denied", "name": member["name"], "email": member["email"], "approved": False, } webpush(member["subscription"], json.dumps(data_message), vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=VAPID_CLAIMS) except WebPushException as ex: print("user subscription is offline") return "user removed from waiting list", 200 return "user removed from waiting list", 200 else: return "No member found in awaiting list", 404 else: return "Wrong Headers", 403
def remove_member(): headers = request.headers if 'Name' in headers.keys() and 'Email' in headers.keys(): member = db.Members.find_one_and_delete({ 'name': headers['name'], 'email': headers['email'] }) if member: try: if member["subscription"]: data_message = { "title": "Remove Member", "body": member["name"] + " , " + member["email"] + ", your have been removed, please sign up", "name": member["name"], "email": member["email"], "approved": False, } webpush(member["subscription"], json.dumps(data_message), vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=VAPID_CLAIMS) except WebPushException as ex: print("user subscription is offline") return "member removed", 200 return "member removed", 200 else: return "No member found in member list", 404 else: return "Wrong Headers", 403
def notif(): print("working") hours = datetime.now().strftime("%H") print(hours) minutes = datetime.now().strftime("%M") seconds = datetime.now().strftime("%S") page = requests.get("http://www.espn.com/tennis/schedule") soup = BeautifulSoup(page.content, 'html.parser') soup.prettify() tables = soup.find_all("table") currtable = tables[0].find_all("tr")[2:] curretable = [] for tr in tables[0].find_all("tr")[2:]: tds = tr.find_all("td") curretable.append(tds[1].text) print(curretable) if hours == "00": print("time to send a notification") if y: print(y[0]) m = ast.literal_eval(y[0]['endpoint']) print(m) webpush( m, data=str(curretable), vapid_private_key="tgX_vQz113iCfMtdEW41oaLQFyKb3fjP4x4nkDw0AMs", vapid_claims={ "sub": "mailto:[email protected]", "aud": "https://fcm.googleapis.com" })
def create_admin(name, email, subscription_info, loc): data_message = { "title": "You are an Admin", "name": name, "email": email, "approved": True, "subscription": subscription_info, } if subscription_info: try: webpush(subscription_info, json.dumps(data_message), vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=VAPID_CLAIMS) except WebPushException as ex: print("Admin subscription is offline") print("No Admins. Making " + name + " an Admin!") member = { "name": name, "email": email, "subscription": subscription_info, "loc": loc, "admin": True } db.Members.insert_one({ "name": name, "email": email, "subscription": subscription_info, "loc": loc, "admin": True }) return member
def notificar(id_usuario): usuario = Usuario.por_id(id_usuario) json = request.get_json() webpush( # Objeto recebido no momento que o usuário aceita receber as notificações # deverá ser no formato de dict subscription_info=json_convert.loads(usuario.push_object), # Corpo da notificação, para uma notificação simples, utilize o padrão abaixo # "notification":{ # "title":"Portugal vs. Denmark", # "body":"great match!" # } # deverá ser um json serializado data=json.get('notificacao'), # A Chave privada gerada anteriormente com o web-push generate-vapid-keys --json vapid_private_key=app.config['VAPID_PRIVATE_KEY'], # Dict obrigatório para a autorização # https://github.com/web-push-libs/vapid/tree/master/python # para maiores informações vapid_claims={ "sub": "mailto:[email protected]" } ) return Ok(True).to_json()
def send_notification(name, uid): message_data = {'title': 'NotificC', 'body': '%s has changed.' % (name)} with sqlite3.connect('shared/data.db') as conn: conn.row_factory = sqlite3.Row cursor = conn.cursor() cursor.execute("SELECT * FROM pms") results = cursor.fetchall() for result in results: result = dict(result) try: webpush( subscription_info={ 'endpoint': result['endpoint'], 'keys': { 'p256dh': result['p256dh'], 'auth': result['auth'] } }, data=json.dumps(message_data), vapid_private_key='./keys/private_key.pem', vapid_claims={ "aud": result['base_endpoint'], "exp": int(time.time()) + 86400, "sub": "mailto:[email protected]" # dummy email }) except WebPushException as exception: print(exception.message)
def test_send_vapid(self, mock_post): mock_post.return_value.status_code = 200 subscription_info = self._gen_subscription_info() data = "Mary had a little lamb" webpush(subscription_info=subscription_info, data=data, vapid_private_key=self.vapid_key, vapid_claims={"sub": "mailto:[email protected]"}, content_encoding="aesgcm", headers={"Test-Header": "test-value"}) assert subscription_info.get('endpoint') == mock_post.call_args[0][0] pheaders = mock_post.call_args[1].get('headers') assert pheaders.get('ttl') == '0' def repad(str): return str + "===="[:len(str) % 4] auth = json.loads( base64.urlsafe_b64decode( repad(pheaders['authorization'].split('.')[1])).decode('utf8')) assert subscription_info.get('endpoint').startswith(auth['aud']) assert 'vapid' in pheaders.get('authorization') ckey = pheaders.get('crypto-key') assert 'dh=' in ckey assert pheaders.get('content-encoding') == 'aesgcm' assert pheaders.get('test-header') == 'test-value'
def push(): request_body = request.get_json() username = request_body.get('username') application_id = request_body.get('applicationId') subscription_info = request_body.get('subscriptionInfo') notification = {'notification': request_body.get('notification')} try: wp.webpush(subscription_info=subscription_info, data=json.dumps(notification), vapid_private_key=VAPID.get("PRIVATE_KEY"), vapid_claims=VAPID.get("CLAIMS")) except wp.WebPushException as ex: print("I'm sorry, Dave, but I can't do that: {}", repr(ex)) # Mozilla returns additional information in the body of the response. if ex.response and ex.response.json(): extra = ex.response.json() print("Remote service replied with a {}:{}, {}", extra.code, extra.errno, extra.message) else: print(ex.response) except Exception as e: print(e) return jsonify(notification)
def notify(): items = Subscriber.query.filter(Subscriber.is_active == True).all() app.logger.info(f"items: {type(items)}:{str(items)}") # [app.logger.info(type(i.is_active), i.is_active) for i in Subscriber.query.all()] count = 0 app.logger.info(f"pushing with private key: {WEBPUSH_VAPID_PRIVATE_KEY}") vapid_claim['exp'] = int(time.time() + 7200) app.logger.info(f"pushing with VAPID claims: {vapid_claim}") for item in items: app.logger.info(type(item.subscription_info), item.subscription_info) try: # app.logger.info(type(json.loads(item.subscription_info)), # json.loads(item.subscription_info.replace("\'","\"")), # json.loads(item.subscription_info.replace("'",'"'))) # if "'" in item.subscription_info: # subscription_method = json.loads(item.subscription_info.replace("\'","\"")) # else: # subscription_method = json.loads(item.subscription_info) webpush( # subscription_info=subscription_method, # subscription_info=json.loads(item.subscription_info), subscription_info=json.loads( item.subscription_info.replace("None", "null").replace("\'", "\"")), data="Investigate sea monster at: lat:19.759 lng:-154.9845", vapid_private_key=WEBPUSH_VAPID_PRIVATE_KEY, vapid_claims=vapid_claim) count += 1 except WebPushException as ex: logging.exception("webpush fail") app.logger.info(f"{Subscriber.query.all()}") return "{} notification(s) sent".format(count)
def remove_member(): headers = request.headers if 'Email' in headers.keys() and 'Adminemail' in headers.keys(): if headers['email'] == headers['adminemail']: return "Can't remove yourself", 400 admin = db.Members.find_one({'email': re.compile(headers['adminemail'], re.IGNORECASE)}) group = get_group_by_email(headers['adminemail']) if admin and group and is_admin(headers['adminemail']): member = db.Members.find_one_and_delete({'email': re.compile(headers['email'], re.IGNORECASE)}) group = get_group_by_email(headers['email']) if group and headers['email'].lower() in group['admin']: group['admin'].remove(headers['email'].lower()) db.Groups.save(group) if member: if member["subscription"]: for sub in member["subscription"]: try: data_message = { "title": "Remove Member", "body": member["email"] + ", your membership has been removed, please sign up", "email": member["email"], "approved": False, } webpush(sub, json.dumps(data_message), vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=get_vapid_claims_for_endpoint(sub['endpoint'])) except WebPushException as ex: print("user subscription is offline") return "member removed", 200 else: return "No member found in member list", 404 else: return "Not admin", 400 else: return "Wrong Headers", 403
def pushMsg(user, msg, url): # endpoint是user註冊通知時的瀏覽器or裝置資訊 # p256dh & auth是用來加密推播出去的訊息 try: webpush( subscription_info={ "endpoint": user.webPushEndpoint, "keys": { "p256dh": user.webPushP256dh, "auth": user.webPushAuth } }, data=json.dumps({ 'msg': msg, 'url': url }, ensure_ascii=False), vapid_private_key= "2IH9egUDh7MrF9OHQhPC9PVCrQc-YxtTQl4yWt1V-gI", #"JuPocmyJjcg85LpvGFcI4AFb-OMRRskHQ13qm1VjDlA",# 找自己的 vapid_claims={"sub": "mailto:[email protected]"}, ttl=60 * 1, ) except WebPushException as e: print('error:', repr(e)) # Mozilla returns additional information in the body of the response. if e.response and e.response.json(): extra = e.response.json() print("Remote service replied with a {}:{}, {}", extra.code, extra.errno, extra.message) return HttpResponse(True)
def test_timeout(self, mock_post): mock_post.return_value.status_code = 200 subscription_info = self._gen_subscription_info() WebPusher(subscription_info).send(timeout=5.2) eq_(mock_post.call_args[1].get('timeout'), 5.2) webpush(subscription_info, timeout=10.001) eq_(mock_post.call_args[1].get('timeout'), 10.001)
def __send(self, data, endpoint, key, authsecret, verbose=False): try: webpush( subscription_info={ 'endpoint': endpoint, 'keys': { 'p256dh': key, 'auth': authsecret }, 'contentEncoding': 'aesgcm' }, data=json.dumps(data), vapid_private_key=self.vapid_private, vapid_claims={ 'sub': 'mailto:' + self.admin_email } ) return True except WebPushException as ex: if verbose: print("Error sending push notification: {}", repr(ex)) if ex.response and ex.response.json(): extra = ex.response.json() if verbose: print("Remote service replied with a {}:{}, {}", extra.code, extra.errno, extra.message) return False
def _send_webpush(subscription_info: dict, data: dict) -> bool: """ Send a webpush message asynchronously """ if not WEB_PUSH_ENABLED: return False json_data = json.dumps(data) try: webpush( subscription_info=subscription_info, data=json_data, vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=VAPID_CLAIMS, ) return True except WebPushException as error: logger.error(error) # Mozilla returns additional information in the body of the response. if error.response and error.response.json(): logger.error(error.response.json()) return False except TypeError as error: logger.error(error) raise error
def create_admin(email, group_id, group_name, subscription_info, password): member = { "email": email, "subscription": [subscription_info], "group": group_id, "password": password, "name": email[:email.find("@")].replace(".", " ").title(), "sendEmail": False, "reports": [] } db.Members.insert_one(member) data_message = { "title": "Welcome " + email, "body": "You are the admin of " + group_name, "email": email, "approved": True, "subscription": subscription_info, } if subscription_info: try: webpush(subscription_info, json.dumps(data_message), vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=get_vapid_claims_for_endpoint(subscription_info['endpoint'])) except WebPushException as ex: print("Admin subscription is offline") print("No Admins. Making " + email + " an Admin!") return member
def save_model(self, request, obj, form, change): imgUrl = obj.image.url if not obj.author: obj.author = request.user if obj.push_update: users = UserProfile.objects.all() for user in users: if user.subscription != None and user.subscription != "": try: webpush(subscription_info=json.loads( user.subscription), data="tips/listicle/" + str(obj.id) + "^" + obj.title + "^" + imgUrl, vapid_private_key=keys. SERVICE_WORKER_PUSH_PRIVATE_KEY, vapid_claims={ "sub": "mailto:[email protected]", }) print("push", obj.push_update, change) except WebPushException as ex: print("I'm sorry, Dave, but I can't do that: {}", repr(ex)) # Mozilla returns additional information in the body of the response. if ex.response and ex.response.json(): extra = ex.response.json() print("Remote service replied with a {}:{}, {}", extra.code, extra.errno, extra.message) obj.push_update = False obj.save()
def test_send_vapid(self, mock_post): mock_post.return_value.status_code = 200 subscription_info = self._gen_subscription_info() data = "Mary had a little lamb" webpush(subscription_info=subscription_info, data=data, vapid_private_key=self.vapid_key, vapid_claims={"sub": "mailto:[email protected]"}) eq_(subscription_info.get('endpoint'), mock_post.call_args[0][0]) pheaders = mock_post.call_args[1].get('headers') eq_(pheaders.get('ttl'), '0') def repad(str): return str + "===="[:len(str) % 4] auth = json.loads( base64.urlsafe_b64decode( repad(pheaders['authorization'].split('.')[1])).decode('utf8')) ok_(subscription_info.get('endpoint').startswith(auth['aud'])) ok_('encryption' in pheaders) ok_('WebPush' in pheaders.get('authorization')) ckey = pheaders.get('crypto-key') ok_('p256ecdsa=' in ckey) ok_('dh=' in ckey) eq_(pheaders.get('content-encoding'), 'aesgcm')
def send_push_notifications(self, msg): with db.db_connect().cursor() as cursor: cursor.execute( "SELECT * FROM push_notification_auth WHERE user_id=%s", (self.car_query["car_query"]["user_id"])) auth_list = cursor.fetchall() for auth in auth_list: print("SENDING PUSH NOTIFICATION") auth_json = auth["auth_json"] try: pywebpush.webpush( json.loads(auth_json), data=json.dumps({ "title": "Pasikeitė paieškos rezultatai", "body": f"{self.car_query['make_model']['make']} {self.car_query['make_model']['model_name']}", "href": f"/users/{self.car_query['car_query']['user_id']}/messages" }), vapid_private_key='./vapid_private.pem', vapid_claims={"sub": "mailto:[email protected]"}) except pywebpush.WebPushException as err: print("Web push failed:") print(err) if "expired" in err.message: cursor.execute( "DELETE FROM `push_notification_auth` WHERE id=%s", auth["id"]) cursor.connection.commit() cursor.connection.close()
def send_push_msg_to_admins(name, email, loc, subscription_info): admins = db.Members.find({"admin": True}) if admins and admins.count() > 0: for doc in admins: print("ADMIN: " + str(doc)) try: if doc["subscription"]: for sub in doc["subscription"]: data_message = { "title": "User approval", "body": name + " , " + email + ", wants to register", "name": name, "email": email, "admin": True } webpush(sub, json.dumps(data_message), vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=VAPID_CLAIMS, timeout=10) except WebPushException as ex: print("Admin subscription is offline") db.awaitingMembers.insert_one({ "name": name, "email": email, "subscription": subscription_info, "loc": loc, }) return False else: return create_admin(name, email, subscription_info, loc)
def send_webpush_user(self, user, message): try: if user.pf_endpoint and user.pf_p256dh and user.pf_auth: webpush( subscription_info={ "endpoint": user.pf_endpoint, "keys": { "p256dh": user.pf_p256dh, "auth": user.pf_auth }, }, data=message, vapid_private_key=settings.VAPID_PRIVATE_KEY, vapid_claims={ "sub": "mailto:[email protected]", }, ) except WebPushException as ex: print("Web Push Failed with Exception: {}", repr(ex)) if ex.response and ex.response.json(): extra = ex.response.json() print( "Remote service replied with a {}:{}, {}", extra.code, extra.errno, extra.message, )
def send_notification(): if current_user.is_anonymous: return abort(404) title = request.form['title'] link = request.form['link'] message = request.form['message'] subscribers = models.Subscriber.query.all() for subscriber in subscribers: try: webpush(subscription_info=subscriber.subscription_json, data=json.dumps({ 'title': title, 'message': message, 'link': link }), vapid_private_key=app.config['VAPID_PRIVATE_KEY'], vapid_claims={"sub": "mailto:[email protected]"}) except: pass notification = models.Notification(user=current_user, title=title, message=message, link=link, date=datetime.datetime.now()) db.session.add(notification) db.session.commit() return redirect(url_for('admin'))
def add_user(): headers = request.headers if 'Email' in headers.keys(): member = db.awaitingMembers.find_one({'email': re.compile(headers['email'], re.IGNORECASE)}) if member: db.awaitingMembers.find_one_and_delete({'email': re.compile(headers['email'], re.IGNORECASE)}) db.Members.insert_one(member) for sub in member["subscription"]: try: data_message = { "title": "Welcome " + member["email"], "email": member["email"], "name": member["name"], "body": "Use this app wisely :)", "admin": False, "approved": True, "sub": sub, } webpush(sub, json.dumps(data_message), vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=get_vapid_claims_for_endpoint(sub['endpoint'])) except WebPushException as ex: print("user subscription is offline") return "User added" else: return "No member found in awaiting list", 404 else: return "Wrong Headers", 403
def notify(message): WEBPUSH_VAPID_PRIVATE_KEY = 'MGSKy99ZwpSUn_V89wKUsL5mtNij3fbnZzpDKkHddMY' items = Subscriber.query.filter_by(is_active = True).all() count = 0 for item in items: try: print(type(item)) a = json.loads(item.subscription_info) webpush( subscription_info=a, data=message, vapid_private_key=WEBPUSH_VAPID_PRIVATE_KEY, vapid_claims={ "sub": "mailto:[email protected]", "aud": "https://vestelagu.site" } ) count += 1 except WebPushException as ex: logging.exception("webpush fail") return "{} notification(s) sent".format(count)
def push(subi): webpush( subi, "", vapid_private_key="WsRleynSjjH2AbE4d9EYxkyP_VhIE3kVrLjgx2XN7Ic", vapid_claims={"sub": "mailto:[email protected]"} )
def send(subscription: dict, notification: JSONType, **kwargs): '''Send a notification payload to a given subscription.''' webpush( subscription, json.dumps(notification), vapid_private_key=current_app.config['WEBPUSH_VAPID_PRIVATE_KEY'], vapid_claims=current_app.config['WEBPUSH_VAPID_CLAIMS'], **kwargs)
def send_web_push(subscription_information, message_body): try: webpush(subscription_info=subscription_information, data=message_body, vapid_private_key=VAPID_PRIVATE_KEY, vapid_claims=VAPID_CLAIMS) except WebPushException as exception: logger.error(exception)
def push_notification_group(subscription_info, secret: str, new_groups: List[str]): sentry_sdk.set_user({"id": remove_pii(subscription_info["endpoint"])}) text = "Vo formulári na registráciu na očkovanie" if len(new_groups) > 1: text += " pribudli nové skupiny" else: text += " pribudla nová skupina" text += " ľudí na očkovanie: " + ", ".join(new_groups) actions = [ { "action": "register", "title": "Zaregistrovať sa", "icon": url_for("main.static", filename="img/edit.svg", _external=True) }, { "action": "unsubsribe", "title": "Zrušiť odber", "icon": url_for("main.static", filename="img/bell-slash.svg", _external=True) }, ] action_map = { "register": "https://www.old.korona.gov.sk/covid-19-vaccination-form.php", "unsubscribe": url_for("main.group_unsubscribe", secret=secret, _external=True) } try: webpush(subscription_info=subscription_info, data=json.dumps({ "action": "notifyGroups", "body": text, "icon": url_for('main.static', filename="img/virus.svg", _external=True), "actions": actions, "actionMap": action_map }), vapid_private_key=vapid_privkey, vapid_claims=dict(vapid_claims)) except WebPushException as e: if e.response is not None and e.response.status_code == 410: clear_db_push.delay(secret) else: logging.error(e)
def send_push(subscription, payload): """Send a single push notification.""" webpush(subscription_info=subscription, data=json.dumps(payload), ttl=30, vapid_private_key=settings.VAPID_PRIV_KEY, vapid_claims={ "sub": "mailto:[email protected]", })
def test_webpush_vapid_instance(self, vapid_sign, pusher_send): pusher_send.return_value.status_code = 200 subscription_info = self._gen_subscription_info() data = "Mary had a little lamb" vapid_key = py_vapid.Vapid.from_string(self.vapid_key) claims = dict(sub="mailto:[email protected]", aud="https://example.com") webpush( subscription_info=subscription_info, data=data, vapid_private_key=vapid_key, vapid_claims=claims, ) vapid_sign.assert_called_once_with(claims) pusher_send.assert_called_once()
def _push_message(self, payload, **kwargs): """Send the message.""" import jwt from pywebpush import WebPusher, webpush timestamp = int(time.time()) payload['timestamp'] = (timestamp*1000) # Javascript ms since epoch targets = kwargs.get(ATTR_TARGET) if not targets: targets = self.registrations.keys() for target in list(targets): info = self.registrations.get(target) if info is None: _LOGGER.error("%s is not a valid HTML5 push notification" " target", target) continue jwt_exp = (datetime.datetime.fromtimestamp(timestamp) + datetime.timedelta(days=JWT_VALID_DAYS)) jwt_secret = info[ATTR_SUBSCRIPTION][ATTR_KEYS][ATTR_AUTH] jwt_claims = {'exp': jwt_exp, 'nbf': timestamp, 'iat': timestamp, ATTR_TARGET: target, ATTR_TAG: payload[ATTR_TAG]} jwt_token = jwt.encode(jwt_claims, jwt_secret).decode('utf-8') payload[ATTR_DATA][ATTR_JWT] = jwt_token if self._vapid_prv and self._vapid_claims: response = webpush( info[ATTR_SUBSCRIPTION], json.dumps(payload), vapid_private_key=self._vapid_prv, vapid_claims=self._vapid_claims ) else: # Only pass the gcm key if we're actually using GCM # If we don't, notifications break on FireFox gcm_key = self._gcm_key \ if 'googleapis.com' \ in info[ATTR_SUBSCRIPTION][ATTR_ENDPOINT] \ else None response = WebPusher(info[ATTR_SUBSCRIPTION]).send( json.dumps(payload), gcm_key=gcm_key, ttl='86400' ) if response.status_code == 410: _LOGGER.info("Notification channel has expired") reg = self.registrations.pop(target) if not save_json(self.registrations_json_path, self.registrations): self.registrations[target] = reg _LOGGER.error("Error saving registration") else: _LOGGER.info("Configuration saved")
def notification_send(text,active_subscriptions): for cur_active_sub in active_subscriptions: try: expiration_date = time.mktime((datetime.datetime.now() + datetime.timedelta(hours=12)).timetuple()) webpush(cur_active_sub.serialize(), data=json.dumps({ "url":url_for('chat'), "message_title": "Message depuis le chat", "message": text }) , vapid_private_key=app.config["NOTIF_PRIVATE_KEY_PATH"], vapid_claims={ "sub": "mailto:[email protected]", "exp": expiration_date } ) except WebPushException as ex: # If there is an error let's remove the subscription app.logger.error("Subscription for endpoint %s is incorrect ==> Delete it", cur_active_sub) print traceback.print_exc(file=sys.stdout); # Let's remove the notification notification_unsubscribe(cur_active_sub) print("I'm sorry, Dave, but I can't do that: {}", repr(ex)) print(ex.response.json())
def main(): """ Send data """ try: args = get_config() result = webpush( args.sub_info, data=args.data, vapid_private_key=args.key, vapid_claims=args.claims, curl=args.curl, content_encoding=args.encoding) print(result) except Exception as ex: print("ERROR: {}".format(ex))
def test_as_curl(self, opener): subscription_info = self._gen_subscription_info() result = webpush( subscription_info, data="Mary had a little lamb", vapid_claims={ "aud": "https://example.com", "sub": "mailto:[email protected]" }, vapid_private_key=self.vapid_key, curl=True ) for s in [ "curl -vX POST https://example.com", "-H \"crypto-key: p256ecdsa=", "-H \"content-encoding: aes128gcm\"", "-H \"authorization: WebPush ", "-H \"ttl: 0\"", "-H \"content-length:" ]: ok_(s in result)
def webpush_send_message( uri, message, browser, auth, p256dh, application_id=None, **kwargs ): subscription_info = get_subscription_info(application_id, uri, browser, auth, p256dh) try: response = webpush( subscription_info=subscription_info, data=message, vapid_private_key=get_manager().get_wp_private_key(application_id), vapid_claims=get_manager().get_wp_claims(application_id), **kwargs ) results = {"results": [{}]} if not response.ok: results["results"][0]["error"] = response.content results["results"][0]["original_registration_id"] = response.content else: results["success"] = 1 return results except WebPushException as e: raise WebPushError(e.message)
def send_single_push_notification(subscription_info, payload): """ Sending a single push notification containing 'payload' to a subscribed browser """ try: # this takes a while, so put a preloader in the window (for JS clients) response = webpush( subscription_info=subscription_info, data=json.dumps(payload), vapid_private_key=PRIVATE_KEY, vapid_claims={"sub": "mailto:[email protected]",}, timeout=35,#timeout of POST request ttl=120#the ttl of how long the message should live ) # print response.status_code # print "---------------------" # print response.json # print "---------------------" # print response.headers # print "---------------------" # print dir(response) return True, response.status_code except WebPushException as ex: # This may contain the requests response # print("I'm sorry, Dave, but I can't do that: {}", repr(ex)) # Mozilla returns additional information in the body of the response. # print dir(ex.response) # if ex.response and ex.response.json(): # extra = ex.response.json() # print("Remote service replied with a {}:{}, {}", # extra.code, # extra.errno, # extra.message # ) # print ex.response.status_code return False, ex.response.status_code