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 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_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
