\d+)$", DeviceDetailsAPI.as_view(), name="device-details"),
11 | re_path(r"^twilio$", TwilioAPI.as_view(), name="twilio-callback"),
12 | re_path(r"^subscriptions$", SubscriptionsAPI.as_view(), name="notifications-subscriptions"),
13 | re_path(r"^api-docs/", UniversalNotificationsDocsView.as_view(), name="notifications-docs"),
14 | ]
15 |
16 | router = DefaultRouter()
17 | urlpatterns += router.urls
18 |
--------------------------------------------------------------------------------
/universal_notifications/backends/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/backends/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/backends/emails/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/backends/emails/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/backends/emails/models.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/backends/emails/models.py
--------------------------------------------------------------------------------
/universal_notifications/backends/emails/urls.py:
--------------------------------------------------------------------------------
1 | from django.urls import re_path
2 | from django.contrib.admin.views.decorators import staff_member_required
3 |
4 | from universal_notifications.backends.emails.views import FakeEmailSend
5 |
6 | urlpatterns = [
7 | re_path(r"$", staff_member_required(FakeEmailSend.as_view()), name="backends.emails.fake_view"),
8 | ]
9 |
--------------------------------------------------------------------------------
/universal_notifications/backends/emails/views.py:
--------------------------------------------------------------------------------
1 | from django.conf import settings
2 | from django.template import TemplateDoesNotExist
3 | from django.views.generic import TemplateView
4 |
5 | from universal_notifications.notifications import EmailNotification
6 |
7 |
8 | def fake_email_notification_factory(template):
9 | class FakeEmailNotification(EmailNotification):
10 | email_name = template
11 | email_subject = "Fake email!"
12 | check_subscription = False
13 |
14 | def format_receiver(cls, receiver):
15 | return receiver
16 |
17 | def format_receiver_for_notification_history(self, receiver):
18 | return receiver
19 |
20 | return FakeEmailNotification
21 |
22 |
23 | class FakeEmailSend(TemplateView):
24 | template_name = "emails/fake.html"
25 |
26 | def get_context_data(self, **kwargs):
27 | context = super(FakeEmailSend, self).get_context_data(**kwargs)
28 | context["template"] = self.request.GET.get("template")
29 | context["email"] = getattr(settings, "UNIVERSAL_NOTIFICATIONS_FAKE_EMAIL_TO", None)
30 | if context["template"] and context["email"]:
31 | FakeEmailNotification = fake_email_notification_factory(context["template"])
32 | try:
33 | FakeEmailNotification(None, [context["email"]], {}).send()
34 | except TemplateDoesNotExist:
35 | context["template_does_not_exist"] = True
36 | return context
37 |
--------------------------------------------------------------------------------
/universal_notifications/backends/push/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/backends/push/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/backends/push/apns.py:
--------------------------------------------------------------------------------
1 | """
2 | Apple Push Notification Service
3 | Documentation is available on the iOS Developer Library:
4 | https://developer.apple.com/library/ios/documentation/NetworkingInternet/Conceptual/RemoteNotificationsPG/Chapters/ApplePushService.html
5 | """
6 |
7 | import json
8 | import socket
9 | import ssl
10 | import struct
11 | import time
12 | from binascii import unhexlify
13 | from contextlib import closing
14 |
15 | from django.core.exceptions import ImproperlyConfigured
16 | from push_notifications import NotificationError
17 | from push_notifications.settings import PUSH_NOTIFICATIONS_SETTINGS as SETTINGS
18 |
19 | from universal_notifications.backends.push.utils import get_app_settings
20 |
21 |
22 | class APNSError(NotificationError):
23 | pass
24 |
25 |
26 | class APNSServerError(APNSError):
27 | def __init__(self, status, identifier):
28 | super(APNSServerError, self).__init__(status, identifier)
29 | self.status = status
30 | self.identifier = identifier
31 |
32 |
33 | class APNSDataOverflow(APNSError):
34 | pass
35 |
36 |
37 | def _apns_create_socket(address_tuple, app_id):
38 | app_settings = get_app_settings(app_id)
39 | if not app_settings:
40 | raise ImproperlyConfigured('You need to set UNIVERSAL_NOTIFICATIONS_MOBILE_APPS[app_id]'
41 | ' to send messages through APNS')
42 |
43 | certfile = app_settings.get("APNS_CERTIFICATE")
44 | if not certfile:
45 | raise ImproperlyConfigured(
46 | 'You need to set UNIVERSAL_NOTIFICATIONS_MOBILE_APPS[app_id]["APNS_CERTIFICATE"] '
47 | 'to send messages through APNS.'
48 | )
49 |
50 | try:
51 | with open(certfile, "r") as f:
52 | f.read()
53 | except Exception as e:
54 | raise ImproperlyConfigured("The APNS certificate file at %r is not readable: %s" % (certfile, e))
55 |
56 | sock = socket.socket()
57 | sock = ssl.wrap_socket(sock, ssl_version=ssl.PROTOCOL_TLSv1, certfile=certfile)
58 | sock.connect(address_tuple)
59 |
60 | return sock
61 |
62 |
63 | def _apns_create_socket_to_push(app_id):
64 | return _apns_create_socket((SETTINGS["APNS_HOST"], SETTINGS["APNS_PORT"]), app_id)
65 |
66 |
67 | def _apns_pack_frame(token_hex, payload, identifier, expiration, priority):
68 | token = unhexlify(token_hex)
69 | # |COMMAND|FRAME-LEN|{token}|{payload}|{id:4}|{expiration:4}|{priority:1}
70 | frame_len = 3 * 5 + len(token) + len(payload) + 4 + 4 + 1 # 5 items, each 3 bytes prefix, then each item length
71 | frame_fmt = "!BIBH%ssBH%ssBHIBHIBHB" % (len(token), len(payload))
72 | frame = struct.pack(
73 | frame_fmt,
74 | 2, frame_len,
75 | 1, len(token), token,
76 | 2, len(payload), payload,
77 | 3, 4, identifier,
78 | 4, 4, expiration,
79 | 5, 1, priority)
80 |
81 | return frame
82 |
83 |
84 | def _apns_check_errors(sock):
85 | timeout = SETTINGS["APNS_ERROR_TIMEOUT"]
86 | if timeout is None:
87 | return # assume everything went fine!
88 | saved_timeout = sock.gettimeout()
89 | try:
90 | sock.settimeout(timeout)
91 | data = sock.recv(6)
92 | if data:
93 | command, status, identifier = struct.unpack("!BBI", data)
94 | # apple protocol says command is always 8. See http://goo.gl/ENUjXg
95 | assert command == 8, "Command must be 8!"
96 | if status != 0:
97 | raise APNSServerError(status, identifier)
98 | except socket.timeout: # py3, see http://bugs.python.org/issue10272
99 | pass
100 | except ssl.SSLError as e: # py2
101 | if "timed out" not in e.message:
102 | raise
103 | except AttributeError:
104 | pass
105 | finally:
106 | sock.settimeout(saved_timeout)
107 |
108 |
109 | def _apns_send(app_id, token, alert, badge=None, sound=None, category=None, content_available=False,
110 | action_loc_key=None, loc_key=None, loc_args=[], extra={}, identifier=0,
111 | expiration=None, priority=10, socket=None):
112 | data = {}
113 | aps_data = {}
114 |
115 | if action_loc_key or loc_key or loc_args:
116 | alert = alert or {}
117 | if action_loc_key:
118 | alert["action-loc-key"] = action_loc_key
119 | if loc_key:
120 | alert["loc-key"] = loc_key
121 | if loc_args:
122 | alert["loc-args"] = loc_args
123 |
124 | if alert is not None:
125 | aps_data["alert"] = alert
126 |
127 | if badge is not None:
128 | aps_data["badge"] = badge
129 |
130 | if sound is not None:
131 | aps_data["sound"] = sound
132 |
133 | if category is not None:
134 | aps_data["category"] = category
135 |
136 | if content_available:
137 | aps_data["content-available"] = 1
138 |
139 | data["aps"] = aps_data
140 | data.update(extra)
141 |
142 | # convert to json, avoiding unnecessary whitespace with separators (keys sorted for tests)
143 | json_data = json.dumps(data, separators=(",", ":"), sort_keys=True).encode("utf-8")
144 |
145 | max_size = SETTINGS["APNS_MAX_NOTIFICATION_SIZE"]
146 | if len(json_data) > max_size:
147 | raise APNSDataOverflow("Notification body cannot exceed %i bytes" % (max_size))
148 |
149 | # if expiration isn't specified use 1 month from now
150 | expiration_time = expiration if expiration is not None else int(time.time()) + 2592000
151 |
152 | frame = _apns_pack_frame(token, json_data, identifier, expiration_time, priority)
153 |
154 | if socket:
155 | socket.write(frame)
156 | else:
157 | with closing(_apns_create_socket_to_push(app_id)) as socket:
158 | socket.write(frame)
159 | _apns_check_errors(socket)
160 |
161 |
162 | def apns_send_message(device, message=None, description=None, data=None):
163 | """
164 | Sends an APNS notification to a single registration_id.
165 | This will send the notification as form data.
166 |
167 | Note that if set message should always be a string. If it is not set,
168 | it won't be included in the notification. You will need to pass None
169 | to this for silent notifications.
170 | """
171 | alert = {
172 | "title": message,
173 | "body": description
174 | }
175 | # do not send title if description is not provided (notification must contain the body param)
176 | if not description:
177 | alert = {
178 | "body": message
179 | }
180 |
181 | data = data or {}
182 | _apns_send(device.app_id, device.notification_token, alert, **data)
183 |
--------------------------------------------------------------------------------
/universal_notifications/backends/push/fcm.py:
--------------------------------------------------------------------------------
1 | # Send to single device.
2 | from pyfcm import FCMNotification
3 |
4 | from universal_notifications.backends.push.utils import get_app_settings
5 |
6 |
7 | def fcm_send_message(device, message, data=None):
8 | app_settings = get_app_settings(device.app_id)
9 | api_key = app_settings.get('FCM_API_KEY')
10 | if not app_settings or not api_key:
11 | return
12 |
13 | push_service = FCMNotification(api_key=api_key)
14 | return push_service.notify_single_device(
15 | registration_id=device.notification_token,
16 | message_body=message,
17 | data_message=data
18 | )
19 |
--------------------------------------------------------------------------------
/universal_notifications/backends/push/gcm.py:
--------------------------------------------------------------------------------
1 | """
2 | Google Cloud Messaging
3 | Previously known as C2DM
4 | Documentation is available on the Android Developer website:
5 | https://developer.android.com/google/gcm/index.html
6 | """
7 | from django.core.exceptions import ImproperlyConfigured
8 | from push_notifications import NotificationError
9 | from push_notifications.settings import PUSH_NOTIFICATIONS_SETTINGS as SETTINGS
10 |
11 | from universal_notifications.backends.push.utils import get_app_settings
12 |
13 | try:
14 | from urllib.parse import urlencode
15 | from urllib.request import Request, urlopen
16 | except ImportError:
17 | # Python 2 support
18 | from urllib import urlencode
19 |
20 | from urllib2 import Request, urlopen
21 |
22 |
23 | class GCMError(NotificationError):
24 | pass
25 |
26 |
27 | def _gcm_send(app_id, data, content_type):
28 | app_settings = get_app_settings(app_id)
29 | key = app_settings.get('GCM_API_KEY')
30 | if not key:
31 | raise ImproperlyConfigured("No GCM API key set")
32 |
33 | headers = {
34 | "Content-Type": content_type,
35 | "Authorization": "key=%s" % (key),
36 | "Content-Length": str(len(data)),
37 | }
38 |
39 | request = Request(SETTINGS["GCM_POST_URL"], data, headers)
40 | return urlopen(request).read()
41 |
42 |
43 | def _gcm_send_plain(device, data, collapse_key=None, delay_while_idle=False, time_to_live=0):
44 | """
45 | Sends a GCM notification to a single registration_id.
46 | This will send the notification as form data.
47 | If sending multiple notifications, it is more efficient to use
48 | gcm_send_bulk_message() with a list of registration_ids
49 | """
50 |
51 | values = {"registration_id": device.notification_token}
52 |
53 | if collapse_key:
54 | values["collapse_key"] = collapse_key
55 |
56 | if delay_while_idle:
57 | values["delay_while_idle"] = int(delay_while_idle)
58 |
59 | if time_to_live:
60 | values["time_to_live"] = time_to_live
61 |
62 | for k, v in data.items():
63 | values["data.%s" % (k)] = v.encode("utf-8")
64 |
65 | data = urlencode(sorted(values.items())).encode("utf-8") # sorted items for tests
66 |
67 | result = _gcm_send(device.app_id, data, "application/x-www-form-urlencoded;charset=UTF-8")
68 | if result.startswith("Error="):
69 | raise GCMError(result)
70 | return result
71 |
72 |
73 | def gcm_send_message(device, message, data=None, collapse_key=None, delay_while_idle=False, time_to_live=0):
74 | """
75 | Sends a GCM notification to a single registration_id.
76 |
77 | This will send the notification as form data if possible, otherwise it will
78 | fall back to json data.
79 | """
80 | data["message"] = message
81 | args = data, collapse_key, delay_while_idle, time_to_live
82 | try:
83 | return _gcm_send_plain(device, *args)
84 | except GCMError:
85 | # TODO: check error and maybe deactivate user
86 | return False
87 |
--------------------------------------------------------------------------------
/universal_notifications/backends/push/utils.py:
--------------------------------------------------------------------------------
1 | from django.conf import settings
2 |
3 |
4 | def get_app_settings(app_id):
5 | return getattr(settings, "UNIVERSAL_NOTIFICATIONS_MOBILE_APPS", {}).get(app_id)
6 |
--------------------------------------------------------------------------------
/universal_notifications/backends/sms/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/backends/sms/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/backends/sms/abstract.py:
--------------------------------------------------------------------------------
1 | import phonenumbers
2 | from django.conf import settings
3 |
4 |
5 | class SMSEngineAbtract(object):
6 |
7 | def get_service_number(self):
8 | return ''
9 |
10 | def add_to_queue(self, obj):
11 | self.send(obj.message)
12 | obj.message.save()
13 |
14 | def send(self, obj, **kwargs):
15 | raise NotImplementedError
16 |
17 | def parse_received(self, raw):
18 | raise NotImplementedError
19 |
20 | def validate_mobile(self, value):
21 | """Validate if number is mobile
22 |
23 | Arguments:
24 | value {string|phonenumbers.PhoneNumber} -- phone number
25 |
26 | Returns:
27 | bool -- return True if number is mobile
28 | """
29 | if not settings.UNIVERSAL_NOTIFICATIONS_VALIDATE_MOBILE:
30 | return True
31 |
32 | if not isinstance(value, phonenumbers.PhoneNumber):
33 | try:
34 | value = phonenumbers.parse(value, 'US')
35 | except phonenumbers.phonenumberutil.NumberParseException:
36 | return False
37 | return value
38 |
--------------------------------------------------------------------------------
/universal_notifications/backends/sms/base.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.conf import settings
3 |
4 | try:
5 | from django.utils.importlib import import_module
6 | except ImportError:
7 | from importlib import import_module
8 |
9 |
10 | class SMS(object):
11 |
12 | def __new__(cls):
13 | __symbol = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_SMS_ENGINE', 'Twilio').lower()
14 | return getattr(import_module('universal_notifications.backends.sms.engines.' + __symbol), 'Engine')()
15 |
--------------------------------------------------------------------------------
/universal_notifications/backends/sms/engines/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/backends/sms/engines/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/backends/sms/engines/amazonsns.py:
--------------------------------------------------------------------------------
1 | import boto3
2 | from django.conf import settings
3 |
4 | from universal_notifications.backends.sms.abstract import SMSEngineAbtract
5 | from universal_notifications.models import PhoneSent
6 |
7 |
8 | def get_sns_client(lookups=False):
9 | return boto3.client(
10 | 'sns',
11 | aws_access_key_id=getattr(settings, 'AWS_ACCESS_KEY_ID', ''),
12 | aws_secret_access_key=getattr(settings, 'AWS_SECRET_ACCESS_KEY', ''),
13 | region_name=getattr(settings, 'AWS_DEFAULT_REGION', 'us-east-1'),
14 | )
15 |
16 |
17 | class Engine(SMSEngineAbtract):
18 |
19 | def send(self, obj):
20 | if not getattr(settings, 'UNIVERSAL_NOTIFICATIONS_AMAZON_SNS_API_ENABLED', False):
21 | self.status = PhoneSent.STATUS_SENT
22 | return
23 |
24 | if not obj.sms_id:
25 | try:
26 | sns_client = get_sns_client()
27 | response = sns_client.publish(
28 | PhoneNumber=obj.receiver.number,
29 | Message=obj.text,
30 | )
31 | obj.status = PhoneSent.STATUS_SENT
32 | obj.sms_id = response['MessageId']
33 |
34 | except Exception as e:
35 | obj.error_message = e
36 | obj.status = PhoneSent.STATUS_FAILED
37 |
--------------------------------------------------------------------------------
/universal_notifications/backends/sms/engines/twilio.py:
--------------------------------------------------------------------------------
1 | from __future__ import absolute_import
2 |
3 | import phonenumbers
4 | from django.conf import settings
5 | from redis import StrictRedis
6 | from rest_framework.renderers import JSONRenderer
7 | from twilio.base.exceptions import TwilioException
8 | from twilio.rest import Client
9 | from twilio.rest.lookups import Lookups
10 | from ws4redis import settings as private_settings
11 | from ws4redis.redis_store import RedisMessage
12 |
13 | from universal_notifications.backends.sms.abstract import SMSEngineAbtract
14 | from universal_notifications.backends.sms.utils import report_admins
15 | from universal_notifications.models import Phone, PhoneReceived, PhoneReceivedRaw, PhoneReceiver, PhoneSent
16 |
17 |
18 | def get_twilio_client(lookups=False):
19 | if lookups:
20 | return Lookups(settings.UNIVERSAL_NOTIFICATIONS_TWILIO_ACCOUNT,
21 | settings.UNIVERSAL_NOTIFICATIONS_TWILIO_TOKEN)
22 | return Client(settings.UNIVERSAL_NOTIFICATIONS_TWILIO_ACCOUNT,
23 | settings.UNIVERSAL_NOTIFICATIONS_TWILIO_TOKEN)
24 |
25 |
26 | class Engine(SMSEngineAbtract):
27 |
28 | def get_service_number(self):
29 | phone = Phone.objects.all().order_by('used_count').first()
30 | if not phone:
31 | return ''
32 | phone.used_count += 1
33 | phone.save()
34 | return phone.number
35 |
36 | def add_to_queue(self, obj):
37 | if getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_ENABLE_PROXY', False):
38 | connection = StrictRedis(**private_settings.WS4REDIS_CONNECTION)
39 | r = JSONRenderer()
40 | json_data = r.render({'number': obj.from_phone})
41 | channel = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_DISPATCHER_CHANNEL', '__un_twilio_dispatcher')
42 | connection.publish(channel, RedisMessage(json_data))
43 | else:
44 | self.send(obj.message)
45 | obj.message.save()
46 |
47 | def send(self, obj):
48 | if not getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_API_ENABLED', False):
49 | self.status = PhoneSent.STATUS_SENT
50 | return
51 |
52 | if not obj.sms_id:
53 | try:
54 | obj.status = PhoneSent.STATUS_SENT
55 | if not obj.text:
56 | obj.text = '.' # hack for MMS
57 | twilio_client = get_twilio_client()
58 | params = {
59 | 'body': obj.text,
60 | 'to': obj.receiver.number,
61 | 'from_': obj.receiver.service_number,
62 | }
63 | if obj.media:
64 | if obj.media.startswith(('http://', 'https://')):
65 | params['media_url'] = obj.media
66 | else:
67 | params['media_url'] = "%s%s" % (settings.MEDIA_URL, obj.media_raw)
68 | message = twilio_client.messages.create(**params)
69 | obj.sms_id = message.sid
70 | except TwilioException as e:
71 | obj.error_message = e
72 | obj.status = PhoneSent.STATUS_FAILED
73 |
74 | def parse_received(self, raw):
75 | if raw.data.get('AccountSid') != settings.UNIVERSAL_NOTIFICATIONS_TWILIO_ACCOUNT:
76 | raw.status = PhoneReceivedRaw.STATUS_REJECTED
77 | raw.save()
78 | report_admins('Rejected incoming Twilio message', raw)
79 | return
80 |
81 | if raw.data.get('Direction') == 'inbound':
82 | # incoming voice call, handle only recording
83 | if raw.data.get('RecordingUrl'):
84 | # TODO: handle calls
85 | # variables = {'data': raw.data}
86 | # TODO: handle calls
87 | # for user in Account.objects.filter(is_superuser=True):
88 | # send_email('voice_mail', user.email, 'Patient leaved a voice mail', variables)
89 | pass
90 | elif raw.data.get('SmsStatus') == 'received':
91 | receiver, created = PhoneReceiver.objects.update_or_create(
92 | number=raw.data.get('From'),
93 | defaults={"service_number": raw.data.get('To')}
94 | )
95 | if raw.data.get('SmsMessageSid', ''):
96 | try:
97 | PhoneReceived.objects.get(sms_id=raw.data.get('SmsMessageSid', ''))
98 | return
99 | except PhoneReceived.DoesNotExist:
100 | pass
101 |
102 | message = PhoneReceived()
103 | message.receiver = receiver
104 | message.media = raw.data.get('MediaUrl0', '')
105 | message.sms_id = raw.data.get('SmsSid', '')
106 | message.text = raw.data.get('Body', '')
107 | message.type = 'text'
108 | message.raw = raw
109 |
110 | stop_words = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_STOP_WORDS',
111 | ('stop', 'unsubscribe', 'cancel', 'quit', 'end'))
112 | if message.text.lower() in stop_words and not receiver.is_blocked:
113 | receiver.is_blocked = True
114 | receiver.save()
115 | message.is_opt_out = True
116 |
117 | message.save()
118 |
119 | start_words = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_START_WORDS', ('start',))
120 | if message.text.lower() in start_words and receiver.is_blocked:
121 | receiver.is_blocked = False
122 | receiver.save()
123 | else:
124 | try:
125 | message = PhoneSent.objects.get(sms_id=raw.data.get('SmsSid'))
126 | except PhoneSent.DoesNotExist:
127 | return True
128 |
129 | message.status = raw.data.get('SmsStatus')
130 | message.error_code = raw.data.get('ErrorCode')
131 | message.error_message = raw.data.get('ErrorMessage')
132 | error_codes = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_REPORT_ERRORS',
133 | [30001, 30006, 30007, 30009])
134 | if message.error_code in error_codes:
135 | # special report for broken integration/number
136 | report_admins('Message issue', raw)
137 | message.save()
138 | return True
139 |
140 | def validate_mobile(self, value):
141 | """Validate if number is mobile
142 |
143 | Lookup Twilio info about number and validate if carrier is mobile or voip
144 |
145 | Arguments:
146 | value {string|phonenumbers.PhoneNumber} -- phone number
147 |
148 | Returns:
149 | bool -- return True if number is mobile
150 | """
151 | if not settings.UNIVERSAL_NOTIFICATIONS_VALIDATE_MOBILE:
152 | return True
153 |
154 | value = super(Engine, self).validate_mobile(value)
155 | if not value:
156 | return False
157 |
158 | number = phonenumbers.format_number(value, phonenumbers.PhoneNumberFormat.E164)
159 | client = get_twilio_client(lookups=True)
160 | response = client.phone_numbers.get(number, include_carrier_info=True)
161 | if response.carrier['type'] not in ['voip', 'mobile']:
162 | return False
163 | return True
164 |
--------------------------------------------------------------------------------
/universal_notifications/backends/sms/signals.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.conf import settings
3 |
4 | try:
5 | from django.utils.importlib import import_module
6 | except ImportError:
7 | from importlib import import_module
8 |
9 | try:
10 | __path, __symbol = getattr(settings, 'PHONE_RECEIVED_POST_SAVE_FUNC').rsplit('.', 1)
11 | phone_received_post_save = getattr(import_module(__path), __symbol)
12 | except (AttributeError, ImportError):
13 | def phone_received_post_save(sender, instance, created, **kwargs):
14 | pass
15 |
--------------------------------------------------------------------------------
/universal_notifications/backends/sms/utils.py:
--------------------------------------------------------------------------------
1 | import re
2 |
3 | import phonenumbers
4 | from django.conf import settings
5 | from django.contrib.sites.models import Site
6 | from django.core.mail import mail_admins
7 |
8 | try:
9 | from django.utils.importlib import import_module
10 | except ImportError:
11 | from importlib import import_module
12 |
13 |
14 | try:
15 | from django.urls import reverse
16 | except ImportError:
17 | # Django < 2.0
18 | from django.core.urlresolvers import reverse
19 |
20 |
21 | try:
22 | __path, __symbol = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_SEND_SMS_FUNC').rsplit('.', 1)
23 | send_sms = getattr(import_module(__path), __symbol)
24 | except (AttributeError, ImportError):
25 | def send_sms(to_number, text, media=None, priority=9999, send_async=True):
26 | """Send SMS/MMS
27 |
28 | Send SMS/MMS
29 |
30 | Arguments:
31 | to_number {string} -- phone number
32 | text {string} -- SMS/MMS text
33 |
34 | Keyword Arguments:
35 | media {string} -- path or url to media file (default: {None})
36 | priority {number} -- sending order if queued, ascending order (default: {9999})
37 | """
38 | from universal_notifications.tasks import send_message_task
39 |
40 | if send_async:
41 | send_message_task.delay(to_number, text, media, priority)
42 | else:
43 | send_message_task(to_number, text, media, priority)
44 |
45 | try:
46 | # Wide UCS-4 build
47 | emoji_pattern = re.compile(u'['
48 | u'\U0001F300-\U0001F64F'
49 | u'\U0001F680-\U0001F6FF'
50 | u'\u2600-\u26FF\u2700-\u27BF]+',
51 | re.UNICODE)
52 | except re.error:
53 | # Narrow UCS-2 build
54 | emoji_pattern = re.compile(u'('
55 | u'\ud83c[\udf00-\udfff]|'
56 | u'\ud83d[\udc00-\ude4f\ude80-\udeff]|'
57 | u'[\u2600-\u26FF\u2700-\u27BF])+',
58 | re.UNICODE)
59 |
60 |
61 | def clean_text(text):
62 | return emoji_pattern.sub(r'', text)
63 |
64 |
65 | def format_phone(phone):
66 | if not phone:
67 | return ''
68 | region = 'US'
69 | if phone.startswith('+'):
70 | region = None
71 | parsed = phonenumbers.parse(phone, region)
72 | return phonenumbers.format_number(parsed, phonenumbers.PhoneNumberFormat.E164)
73 |
74 |
75 | def report_admins(subject, raw):
76 | url = reverse('admin:universal_notifications_phonereceivedraw_change', args=[raw.id])
77 | domain = Site.objects.get_current().domain
78 | url = ''.join(['http://', domain])
79 | mail_admins(subject, 'Message admin: %s' % url)
80 |
--------------------------------------------------------------------------------
/universal_notifications/backends/twilio/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/backends/twilio/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/backends/twilio/api.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.conf import settings
3 | from django.http import QueryDict
4 | from django.utils.safestring import SafeString
5 | from rest_framework import status
6 | from rest_framework.generics import GenericAPIView
7 | from rest_framework.permissions import AllowAny
8 | from rest_framework.renderers import StaticHTMLRenderer
9 | from rest_framework.response import Response
10 | from rest_framework.serializers import Serializer
11 |
12 | from universal_notifications.backends.sms.utils import clean_text
13 | from universal_notifications.models import PhoneReceivedRaw
14 |
15 |
16 | class TwilioAPI(GenericAPIView):
17 | """
18 | Receive SMS/Phone from Twilio
19 | """
20 | serializer_class = Serializer
21 | permission_classes = (AllowAny,)
22 | renderer_classes = (StaticHTMLRenderer,)
23 |
24 | def post(self, request):
25 | data = request.data
26 |
27 | # Clean emoji for now
28 | if isinstance(data, dict) and data.get('Body'):
29 | if isinstance(data, QueryDict):
30 | data = data.dict()
31 | data['Body'] = clean_text(data['Body'])
32 | PhoneReceivedRaw.objects.create(data=data)
33 |
34 | if data.get('Direction') == 'inbound':
35 | if data.get('CallStatus') == 'ringing': # incoming voice call
36 | text = getattr(settings, 'UNIVERSAL_NOTIFICATIONS_TWILIO_CALL_RESPONSE_DEFAULT',
37 | ''
38 | ''
39 | 'Hello, thanks for calling. '
40 | 'To leave a message wait for the tone.'
41 | ''
42 | '')
43 | return Response(SafeString(text), content_type='text/xml')
44 | return Response({}, status=status.HTTP_202_ACCEPTED)
45 |
--------------------------------------------------------------------------------
/universal_notifications/backends/twilio/fields.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """
3 | From django-extensions
4 |
5 | JSONField automatically serializes most Python terms to JSON data.
6 | Creates a TEXT field with a default value of "{}". See test_json.py for
7 | more information.
8 |
9 | from django.db import models
10 | from django_extensions.db.fields import json
11 |
12 | class LOL(models.Model):
13 | extra = json.JSONField()
14 | """
15 | from __future__ import absolute_import
16 |
17 | import json
18 | import warnings
19 |
20 | import six
21 | from django.core.serializers.json import DjangoJSONEncoder
22 | from django.db import models
23 |
24 |
25 | def dumps(value):
26 | return DjangoJSONEncoder().encode(value)
27 |
28 |
29 | class JSONDict(dict):
30 | """
31 | Hack so repr() called by dumpdata will output JSON instead of
32 | Python formatted data. This way fixtures will work!
33 | """
34 | def __repr__(self):
35 | return dumps(self)
36 |
37 |
38 | class JSONList(list):
39 | """
40 | As above
41 | """
42 | def __repr__(self):
43 | return dumps(self)
44 |
45 |
46 | class JSONField(models.TextField):
47 | """JSONField is a generic textfield that neatly serializes/unserializes
48 | JSON objects seamlessly. Main thingy must be a dict object."""
49 |
50 | def __init__(self, *args, **kwargs):
51 | warnings.warn("Django 1.9 features a native JsonField, this JSONField will "
52 | "be removed somewhere after Django 1.8 becomes unsupported.",
53 | DeprecationWarning)
54 | kwargs['default'] = kwargs.get('default', dict)
55 | models.TextField.__init__(self, *args, **kwargs)
56 |
57 | def get_default(self):
58 | if self.has_default():
59 | default = self.default
60 |
61 | if callable(default):
62 | default = default()
63 |
64 | return self.to_python(default)
65 | return super(JSONField, self).get_default()
66 |
67 | def to_python(self, value):
68 | """Convert our string value to JSON after we load it from the DB"""
69 | if value is None or value == '':
70 | return {}
71 |
72 | if isinstance(value, six.string_types):
73 | res = json.loads(value)
74 | else:
75 | res = value
76 |
77 | if isinstance(res, dict):
78 | return JSONDict(**res)
79 | elif isinstance(res, list):
80 | return JSONList(res)
81 |
82 | return value
83 |
84 | def get_prep_value(self, value):
85 | if not isinstance(value, six.string_types):
86 | return dumps(value)
87 | return super(models.TextField, self).get_prep_value(value)
88 |
89 | def from_db_value(self, value, expression, connection, context=None):
90 | return self.to_python(value)
91 |
92 | def get_db_prep_save(self, value, connection, **kwargs):
93 | """Convert our JSON object to a string before we save"""
94 | if value is None and self.null:
95 | return None
96 | # default values come in as strings; only non-strings should be
97 | # run through `dumps`
98 | if not isinstance(value, six.string_types):
99 | value = dumps(value)
100 |
101 | return value
102 |
103 | def deconstruct(self):
104 | name, path, args, kwargs = super(JSONField, self).deconstruct()
105 | if self.default == '{}':
106 | del kwargs['default']
107 | return name, path, args, kwargs
108 |
--------------------------------------------------------------------------------
/universal_notifications/backends/websockets.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import json
3 |
4 | from django.conf import settings
5 | from rest_framework.renderers import JSONRenderer
6 | from ws4redis.publisher import RedisPublisher
7 | from ws4redis.redis_store import RedisMessage
8 | from ws4redis.subscriber import RedisSubscriber
9 |
10 | from universal_notifications.tasks import ws_received_send_signal_task
11 |
12 |
13 | def publish(user, item=None, additional_data=None):
14 | if additional_data is None:
15 | additional_data = {}
16 | redis_publisher = RedisPublisher(facility='all', users=[user.email])
17 | r = JSONRenderer()
18 | if item is None:
19 | data = {}
20 | else:
21 | data = item.as_dict()
22 | data.update(additional_data)
23 | data = r.render(data)
24 | message = RedisMessage(data)
25 | if getattr(settings, 'TESTING', False):
26 | # Do not send in tests
27 | return
28 | redis_publisher.publish_message(message)
29 |
30 |
31 | class RedisSignalSubscriber(RedisSubscriber):
32 | def publish_message(self, message, expire=None):
33 | try:
34 | message_data = json.loads(message)
35 | # I didn't found any better way to dig out who is subscribed to a given channel (not to mention who
36 | # just have send the given message). User ID can be passed in message, however this opens a hole in the
37 | # system, so - as long as we've only per-user channels (opened with a auth token), it should be safe to
38 | # use email of those users to identify the user.
39 | channel_emails = [str(x).split(":")[2] for x in self._subscription.channels.keys()]
40 |
41 | ws_received_send_signal_task.apply_async(args=[message_data, channel_emails])
42 | except Exception:
43 | # I mean it, catch everything, log it if needed but do catch everything
44 | pass
45 | return super(RedisSignalSubscriber, self).publish_message(message, expire)
46 |
--------------------------------------------------------------------------------
/universal_notifications/docs.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from importlib import import_module
3 |
4 | from django.apps import apps
5 | from django.template import TemplateDoesNotExist, TemplateSyntaxError
6 | from django.utils.safestring import mark_safe
7 | from rest_framework.compat import coreapi
8 |
9 | from universal_notifications.notifications import (EmailNotification, NotificationBase, PushNotification,
10 | SMSNotification, WSNotification)
11 |
12 | BASE_NOTIFICATIONS = (EmailNotification, NotificationBase, PushNotification, SMSNotification, WSNotification)
13 |
14 |
15 | class BaseGenerator(object):
16 | def __init__(self, obj, *args, **kwargs):
17 | super(BaseGenerator, self).__init__(*args, **kwargs)
18 | self._obj = obj
19 |
20 | def get_summary(self):
21 | return "TODO: summary"
22 |
23 | def get_type(self):
24 | return "TODO: type"
25 |
26 | def get_notes(self):
27 | parts = [self.get_summary() + "\n", self._obj.__doc__]
28 | if self._obj.check_subscription:
29 | parts.append("Subscription Category: %s" % self._obj.category)
30 | parts.append(self.get_class_specific_notes())
31 | return "
".join(part for part in parts if part and part.strip()) # display only non empty parts
32 |
33 | def get_class_specific_notes(self):
34 | return "TODO: notes"
35 |
36 | def get_serializer(self):
37 | return None
38 |
39 | def skip(self):
40 | return False
41 |
42 |
43 | class WSDocGenerator(BaseGenerator):
44 | def get_summary(self):
45 | return self._obj.message
46 |
47 | def get_type(self):
48 | return self.get_serializer().__name__
49 |
50 | def get_class_specific_notes(self):
51 | data = self.get_serializer().__name__
52 | if self._obj.serializer_many:
53 | data = "[%s*]" % data
54 | return "Message
%s
Data
%s" % (self._obj.message, data)
55 |
56 | def get_serializer(self):
57 | if self._obj.serializer_class is None:
58 | # handling scase when serializer_class is defined during __init__
59 | return self._obj().serializer_class
60 | return self._obj.serializer_class
61 |
62 | def skip(self):
63 | return not self._obj.message
64 |
65 |
66 | class SMSDocGenerator(BaseGenerator):
67 | def get_summary(self):
68 | return "SMS"
69 |
70 | def get_type(self):
71 | return None
72 |
73 | def get_class_specific_notes(self):
74 | return "Template:
%s" % self._obj.message
75 |
76 | def skip(self):
77 | return not self._obj.message
78 |
79 |
80 | class EmailDocGenerator(BaseGenerator):
81 | template_loader = None
82 |
83 | # ++ THIS IS UGLY. TODO: Find better method
84 | @classmethod
85 | def get_template_loader(cls):
86 | if not cls.template_loader:
87 | from django.template.engine import Engine
88 | from django.template.loaders.filesystem import Loader
89 |
90 | default_template_engine = Engine.get_default()
91 | cls.template_loader = Loader(default_template_engine)
92 | return cls.template_loader
93 |
94 | @classmethod
95 | def get_template(cls, template_name):
96 | template_loader = cls.get_template_loader()
97 | try:
98 | source, dummy = template_loader.load_template_source(template_name)
99 | return source
100 | except (TemplateDoesNotExist, TemplateSyntaxError):
101 | return ""
102 | # --
103 |
104 | def get_summary(self):
105 | return self._obj.email_name
106 |
107 | def get_type(self):
108 | return None
109 |
110 | def get_class_specific_notes(self):
111 | notes = "Subject:
%s
Preview:
%s" % (
112 | self._obj.email_subject,
113 | self.get_template("emails/email_%s.html" % self._obj.email_name)
114 | )
115 | return mark_safe(notes)
116 |
117 | def skip(self):
118 | return not self._obj.email_name
119 |
120 |
121 | class NotificationsDocs(object):
122 | _registry = {}
123 | _autodiscovered = False
124 | _serializers = set()
125 | _generator_mapping = {
126 | EmailNotification: EmailDocGenerator,
127 | SMSNotification: SMSDocGenerator,
128 | WSNotification: WSDocGenerator
129 | }
130 |
131 | @classmethod
132 | def autodiscover(cls):
133 | if cls._autodiscovered:
134 | return
135 |
136 | cls._autodiscovered = True
137 |
138 | # classes
139 | for app_config in apps.get_app_configs():
140 | if app_config.name == "universal_notifications": # no self importing
141 | continue
142 | try:
143 | module = import_module("%s.%s" % (app_config.name, "notifications"))
144 | for key in dir(module):
145 | item = getattr(module, key)
146 | if issubclass(item, NotificationBase) and item not in BASE_NOTIFICATIONS:
147 | notification_type = item.get_type()
148 | if notification_type not in cls._registry:
149 | cls._registry[notification_type] = {}
150 | item_key = "%s.%s" % (key, app_config.name)
151 | item_path = "%s (%s.notifications)" % (key, app_config.name)
152 |
153 | generator = cls.get_generator(item)
154 | if not generator.skip():
155 | serializer = generator.get_serializer()
156 | if serializer:
157 | cls._serializers.add(serializer)
158 | cls._registry[notification_type][item_key] = {"cls": item, "path": item_path}
159 | except Exception:
160 | pass
161 |
162 | @classmethod
163 | def get_types(cls):
164 | return sorted(cls._registry.keys())
165 |
166 | @classmethod
167 | def get_notifications(cls, notification_type):
168 | return sorted(cls._registry.get(notification_type, {}).items(), key=lambda x: x[0])
169 |
170 | @classmethod
171 | def get_generator(cls, notification_cls):
172 | for key_cls, generator_cls in cls._generator_mapping.items():
173 | if issubclass(notification_cls, key_cls):
174 | return generator_cls(notification_cls)
175 | return BaseGenerator(notification_cls)
176 |
177 | @classmethod
178 | def generate_notifications_docs(cls, notification_type):
179 | links = {}
180 | for key, value in cls.get_notifications(notification_type):
181 | generator = cls.get_generator(value["cls"])
182 | links[value["path"]] = coreapi.Link(
183 | title=key,
184 | description=generator.get_notes(),
185 | action="GET",
186 | url=value["path"]
187 | )
188 |
189 | return links
190 |
--------------------------------------------------------------------------------
/universal_notifications/management/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/management/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/management/commands/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/management/commands/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/management/commands/check_twilio_proxy.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.conf import settings
3 | from django.core.management.base import BaseCommand
4 | from redis import StrictRedis
5 | from rest_framework.renderers import JSONRenderer
6 | from ws4redis import settings as private_settings
7 | from ws4redis.redis_store import RedisMessage
8 |
9 | from universal_notifications.models import PhonePendingMessages
10 |
11 |
12 | class Command(BaseCommand):
13 | args = ""
14 | help = "Check twilio proxy"
15 |
16 | def handle(self, *args, **options):
17 | connection = StrictRedis(**private_settings.WS4REDIS_CONNECTION)
18 | numbers = PhonePendingMessages.objects.all().values_list("from_phone", flat=True).distinct()
19 | for n in numbers:
20 | r = JSONRenderer()
21 | json_data = r.render({"number": n})
22 | channel = getattr(settings, "UNIVERSAL_NOTIFICATIONS_TWILIO_DISPATCHER_CHANNEL", "__un_twilio_dispatcher")
23 | connection.publish(channel, RedisMessage(json_data))
24 |
--------------------------------------------------------------------------------
/universal_notifications/management/commands/parse_pending_sms.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from datetime import timedelta
3 |
4 | from django.core.management.base import BaseCommand
5 | from django.utils.timezone import now
6 |
7 | from universal_notifications.models import PhoneReceivedRaw
8 | from universal_notifications.tasks import parse_received_message_task
9 |
10 |
11 | class Command(BaseCommand):
12 | args = ""
13 | help = "Check if message parsed"
14 |
15 | def handle(self, *args, **options):
16 | ago = now() - timedelta(minutes=1)
17 | raws = PhoneReceivedRaw.objects.filter(status=PhoneReceivedRaw.STATUS_PENDING, created__lte=ago)
18 | for raw in raws:
19 | parse_received_message_task(raw.id)
20 |
--------------------------------------------------------------------------------
/universal_notifications/management/commands/run_twilio_proxy.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import json
3 | import sys
4 | import threading
5 | import traceback
6 | from time import sleep
7 |
8 | from django.conf import settings
9 | from django.core.management.base import BaseCommand
10 | from raven.contrib.django import DjangoClient
11 | from redis import StrictRedis
12 | from ws4redis import settings as private_settings
13 |
14 | from universal_notifications.models import Phone, PhonePendingMessages
15 |
16 |
17 | class Queue(threading.Thread):
18 | def __init__(self, main, phone):
19 | self.main = main
20 | self.phone = phone
21 | threading.Thread.__init__(self)
22 |
23 | def stop(self):
24 | if self.phone.number in self.main.queues:
25 | self.main.queues.remove(self.phone.number)
26 |
27 | def check_messages(self):
28 | count = 1
29 | while count:
30 | messages = PhonePendingMessages.objects.filter(from_phone=self.phone.number)
31 | count = messages.count()
32 | if count:
33 | self.process_message(messages[0])
34 | sleep(60 / self.phone.rate)
35 | else:
36 | self.stop()
37 |
38 | def process_message(self, message):
39 | message.message.send()
40 | message.message.save()
41 | message.delete()
42 |
43 | def run(self):
44 | try:
45 | self.check_messages()
46 | except Exception:
47 | info = sys.exc_info()
48 | raven_conf = getattr(settings, "RAVEN_CONFIG", False)
49 | if raven_conf and raven_conf.get("dsn"):
50 | client = DjangoClient(raven_conf.get("dsn"))
51 | exc_type, exc_value, exc_traceback = info
52 | error = str(traceback.format_exception(exc_type, exc_value, exc_traceback))
53 | client.capture("raven.events.Message", message="Error Sending message",
54 | extra={"info": error, "number": self.phone.number})
55 | raise Exception(info[1], None, info[2])
56 |
57 |
58 | class Command(BaseCommand):
59 | args = ""
60 | help = "Run twilio proxy"
61 | queues = []
62 |
63 | def create_queue(self, phone):
64 | if phone.number not in self.queues:
65 | t = Queue(self, phone)
66 | t.start()
67 | self.queues.append(phone.number)
68 |
69 | def handle(self, *args, **options):
70 | r = StrictRedis(**private_settings.WS4REDIS_CONNECTION)
71 | p = r.pubsub()
72 | channel = getattr(settings, "UNIVERSAL_NOTIFICATIONS_TWILIO_DISPATCHER_CHANNEL", "__un_twilio_dispatcher")
73 | p.subscribe(channel)
74 |
75 | phones = Phone.objects.all()
76 | for phone in phones:
77 | self.create_queue(phone)
78 |
79 | while True:
80 | message = p.get_message()
81 | if message:
82 | try:
83 | m = json.loads(message["data"])
84 | if m.get("number"):
85 | try:
86 | phone = Phone.objects.get(number=m["number"])
87 | self.create_queue(phone)
88 | except Phone.DoesNotExist:
89 | pass
90 | except (TypeError, ValueError):
91 | pass
92 | sleep(0.001) # be nice to the system :)
93 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/0001_initial.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from __future__ import unicode_literals
3 |
4 | from django.db import migrations, models
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ]
11 |
12 | operations = [
13 | migrations.CreateModel(
14 | name='NotificationHistory',
15 | fields=[
16 | ('id', models.AutoField(verbose_name='ID', serialize=False, auto_created=True, primary_key=True)),
17 | ('created', models.DateTimeField(auto_now_add=True)),
18 | ('group', models.CharField(max_length=50)),
19 | ('klass', models.CharField(max_length=255)),
20 | ('receiver', models.CharField(max_length=255)),
21 | ('details', models.TextField()),
22 | ],
23 | ),
24 | ]
25 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/0002_device.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from __future__ import unicode_literals
3 |
4 | from django.conf import settings
5 | from django.db import migrations, models
6 |
7 |
8 | class Migration(migrations.Migration):
9 |
10 | dependencies = [
11 | migrations.swappable_dependency(settings.AUTH_USER_MODEL),
12 | ('universal_notifications', '0001_initial'),
13 | ]
14 |
15 | operations = [
16 | migrations.CreateModel(
17 | name='Device',
18 | fields=[
19 | ('id', models.AutoField(auto_created=True, verbose_name='ID', serialize=False, primary_key=True)),
20 | ('notification_token', models.TextField()),
21 | ('device_id', models.CharField(max_length=255)),
22 | ('is_active', models.BooleanField(default=True, help_text='Inactive devices will not be sent notifications')),
23 | ('created', models.DateTimeField(auto_now_add=True)),
24 | ('app_id', models.CharField(max_length=100)),
25 | ('platform', models.CharField(choices=[('ios', 'iOS'), ('gcm', 'Google Cloud Messagging (deprecated)'), ('fcm', 'Firebase Cloud Messaging')], max_length=10)),
26 | ('user', models.ForeignKey(to=settings.AUTH_USER_MODEL, related_name='devices', on_delete=models.CASCADE)),
27 | ],
28 | ),
29 | ]
30 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/0003_auto_20170112_0609.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | # Generated by Django 1.10.5 on 2017-01-12 06:09
3 | from __future__ import unicode_literals
4 |
5 | import django.db.models.deletion
6 | from django.db import migrations, models
7 |
8 | import universal_notifications.backends.twilio.fields
9 |
10 |
11 | class Migration(migrations.Migration):
12 |
13 | dependencies = [
14 | ('universal_notifications', '0002_device'),
15 | ]
16 |
17 | operations = [
18 | migrations.CreateModel(
19 | name='Phone',
20 | fields=[
21 | ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
22 | ('number', models.CharField(max_length=20, unique=True)),
23 | ('rate', models.IntegerField(default=6, verbose_name=b'Messages rate')),
24 | ('used_count', models.IntegerField(default=0)),
25 | ],
26 | options={
27 | 'ordering': ['number'],
28 | },
29 | ),
30 | migrations.CreateModel(
31 | name='PhonePendingMessages',
32 | fields=[
33 | ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
34 | ('created', models.DateTimeField(auto_now_add=True)),
35 | ('from_phone', models.CharField(db_index=True, max_length=30)),
36 | ('priority', models.IntegerField(default=9999)),
37 | ],
38 | ),
39 | migrations.CreateModel(
40 | name='PhoneReceived',
41 | fields=[
42 | ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
43 | ('text', models.TextField()),
44 | ('media', models.CharField(blank=True, max_length=255, null=True)),
45 | ('type', models.CharField(choices=[(b'voice', b'voice'), (b'text', b'Text')], default=b'text', max_length=35)),
46 | ('created', models.DateTimeField(auto_now_add=True)),
47 | ('updated', models.DateTimeField(auto_now=True)),
48 | ('sms_id', models.CharField(blank=True, max_length=50)),
49 | ('is_opt_out', models.BooleanField(default=False)),
50 | ],
51 | options={
52 | 'verbose_name': 'Received Message',
53 | 'verbose_name_plural': 'Received Messages',
54 | },
55 | ),
56 | migrations.CreateModel(
57 | name='PhoneReceivedRaw',
58 | fields=[
59 | ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
60 | ('status', models.CharField(choices=[(b'pending', b'Pending'), (b'pass', b'Pass'), (b'fail', b'Fail'), (b'rejected', b'Rejected')], db_index=True, default=b'pending', max_length=35)),
61 | ('data', universal_notifications.backends.twilio.fields.JSONField()),
62 | ('created', models.DateTimeField(auto_now_add=True)),
63 | ('updated', models.DateTimeField(auto_now=True)),
64 | ('exception', models.TextField(blank=True)),
65 | ],
66 | ),
67 | migrations.CreateModel(
68 | name='PhoneReceiver',
69 | fields=[
70 | ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
71 | ('number', models.CharField(db_index=True, max_length=20)),
72 | ('service_number', models.CharField(max_length=20)),
73 | ('is_blocked', models.BooleanField(default=False)),
74 | ],
75 | options={
76 | 'ordering': ['number'],
77 | },
78 | ),
79 | migrations.CreateModel(
80 | name='PhoneSent',
81 | fields=[
82 | ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
83 | ('text', models.TextField()),
84 | ('sms_id', models.CharField(blank=True, max_length=34)),
85 | ('status', models.CharField(choices=[(b'pending', b'Pending'), (b'queued', b'Queued'), (b'failed', b'failed'), (b'sent', b'sent'), (b'no_answer', b'no answer from twilio'), (b'delivered', b'delivered'), (b'undelivered', b'undelivered')], default=b'pending', max_length=35)),
86 | ('twilio_error_code', models.CharField(blank=True, max_length=100, null=True)),
87 | ('twilio_error_message', models.TextField(blank=True, null=True)),
88 | ('created', models.DateTimeField(auto_now_add=True)),
89 | ('updated', models.DateTimeField(auto_now=True)),
90 | ('media_raw', models.CharField(blank=True, max_length=255, null=True)),
91 | ('media', models.CharField(blank=True, max_length=255, null=True)),
92 | ('receiver', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='universal_notifications.PhoneReceiver')),
93 | ],
94 | options={
95 | 'verbose_name': 'Sent Message',
96 | 'verbose_name_plural': 'Sent Messages',
97 | },
98 | ),
99 | migrations.AlterIndexTogether(
100 | name='phonereceiver',
101 | index_together=set([('number', 'service_number')]),
102 | ),
103 | migrations.AddField(
104 | model_name='phonereceived',
105 | name='raw',
106 | field=models.ForeignKey(blank=True, editable=False, null=True, on_delete=django.db.models.deletion.SET_NULL, to='universal_notifications.PhoneReceivedRaw'),
107 | ),
108 | migrations.AddField(
109 | model_name='phonereceived',
110 | name='receiver',
111 | field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='universal_notifications.PhoneReceiver'),
112 | ),
113 | migrations.AddField(
114 | model_name='phonependingmessages',
115 | name='message',
116 | field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, to='universal_notifications.PhoneSent'),
117 | ),
118 | ]
119 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/0004_auto_20170124_0731.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from __future__ import unicode_literals
3 |
4 | import django.db.models.deletion
5 | from django.conf import settings
6 | from django.db import migrations, models
7 |
8 | import universal_notifications.backends.twilio.fields
9 |
10 |
11 | class Migration(migrations.Migration):
12 |
13 | dependencies = [
14 | migrations.swappable_dependency(settings.AUTH_USER_MODEL),
15 | ('universal_notifications', '0003_auto_20170112_0609'),
16 | ]
17 |
18 | operations = [
19 | migrations.CreateModel(
20 | name='UnsubscribedUser',
21 | fields=[
22 | ('id', models.AutoField(verbose_name='ID', primary_key=True, serialize=False, auto_created=True)),
23 | ('unsubscribed_from_all', models.BooleanField(default=False)),
24 | ('unsubscribed', universal_notifications.backends.twilio.fields.JSONField(default=dict)),
25 | ('user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),
26 | ],
27 | ),
28 | migrations.AddField(
29 | model_name='notificationhistory',
30 | name='category',
31 | field=models.CharField(max_length=255, default='system'),
32 | preserve_default=False,
33 | ),
34 | migrations.AlterField(
35 | model_name='phone',
36 | name='rate',
37 | field=models.IntegerField(verbose_name='Messages rate', default=6),
38 | ),
39 | migrations.AlterField(
40 | model_name='phonereceived',
41 | name='type',
42 | field=models.CharField(max_length=35, default='text', choices=[('voice', 'voice'), ('text', 'Text')]),
43 | ),
44 | migrations.AlterField(
45 | model_name='phonereceivedraw',
46 | name='status',
47 | field=models.CharField(max_length=35, db_index=True, default='pending', choices=[('pending', 'Pending'), ('pass', 'Pass'), ('fail', 'Fail'), ('rejected', 'Rejected')]),
48 | ),
49 | migrations.AlterField(
50 | model_name='phonesent',
51 | name='status',
52 | field=models.CharField(max_length=35, default='pending', choices=[('pending', 'Pending'), ('queued', 'Queued'), ('failed', 'failed'), ('sent', 'sent'), ('no_answer', 'no answer from twilio'), ('delivered', 'delivered'), ('undelivered', 'undelivered')]),
53 | ),
54 | ]
55 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/0005_auto_20170316_1814.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | # Generated by Django 1.10.6 on 2017-03-16 18:14
3 | from __future__ import unicode_literals
4 |
5 | from django.db import migrations, models
6 |
7 |
8 | class Migration(migrations.Migration):
9 |
10 | dependencies = [
11 | ('universal_notifications', '0004_auto_20170124_0731'),
12 | ]
13 |
14 | operations = [
15 | migrations.RenameField(
16 | model_name='phonesent',
17 | old_name='twilio_error_code',
18 | new_name='error_code',
19 | ),
20 | migrations.RenameField(
21 | model_name='phonesent',
22 | old_name='twilio_error_message',
23 | new_name='error_message',
24 | ),
25 | migrations.AlterField(
26 | model_name='phonereceiver',
27 | name='service_number',
28 | field=models.CharField(blank=True, max_length=20),
29 | ),
30 | ]
31 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/0006_auto_20170323_0634.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from __future__ import unicode_literals
3 |
4 | from django.db import migrations, models
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ('universal_notifications', '0005_auto_20170316_1814'),
11 | ]
12 |
13 | operations = [
14 | migrations.AlterField(
15 | model_name='phonereceiver',
16 | name='number',
17 | field=models.CharField(max_length=20, unique=True, db_index=True),
18 | ),
19 | ]
20 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/0007_auto_20170323_0649.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from __future__ import unicode_literals
3 |
4 | from django.db import migrations, models
5 |
6 |
7 | class Migration(migrations.Migration):
8 |
9 | dependencies = [
10 | ('universal_notifications', '0006_auto_20170323_0634'),
11 | ]
12 |
13 | operations = [
14 | migrations.AlterField(
15 | model_name='phonesent',
16 | name='sms_id',
17 | field=models.CharField(max_length=50, blank=True),
18 | ),
19 | ]
20 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/0008_auto_20170704_0810.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | # Generated by Django 1.11.3 on 2017-07-04 12:10
3 | from __future__ import unicode_literals
4 |
5 | import django.db.models.deletion
6 | from django.db import migrations, models
7 |
8 |
9 | class Migration(migrations.Migration):
10 |
11 | dependencies = [
12 | ('contenttypes', '0002_remove_content_type_name'),
13 | ('universal_notifications', '0007_auto_20170323_0649'),
14 | ]
15 |
16 | operations = [
17 | migrations.AddField(
18 | model_name='notificationhistory',
19 | name='content_type',
20 | field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.SET_NULL, to='contenttypes.ContentType'),
21 | ),
22 | migrations.AddField(
23 | model_name='notificationhistory',
24 | name='object_id',
25 | field=models.PositiveIntegerField(null=True),
26 | ),
27 | ]
28 |
--------------------------------------------------------------------------------
/universal_notifications/migrations/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/HealthByRo/universal_notifications/67552a42ff7625971e0b2aa7ee42984db8be159c/universal_notifications/migrations/__init__.py
--------------------------------------------------------------------------------
/universal_notifications/models.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.conf import settings
3 | from django.contrib.contenttypes.fields import GenericForeignKey
4 | from django.contrib.contenttypes.models import ContentType
5 | from django.db import models
6 | from django.db.models.signals import post_save
7 | from django.utils.encoding import force_str
8 | from phonenumbers import NumberParseException
9 |
10 | from universal_notifications.backends.push.apns import apns_send_message
11 | from universal_notifications.backends.push.fcm import fcm_send_message
12 | from universal_notifications.backends.push.gcm import gcm_send_message
13 | from universal_notifications.backends.sms.signals import phone_received_post_save
14 | from universal_notifications.backends.sms.utils import format_phone
15 | from universal_notifications.backends.twilio.fields import JSONField
16 |
17 | AUTH_USER_MODEL = getattr(settings, "AUTH_USER_MODEL", "auth.User")
18 | TWILIO_MAX_RATE = getattr(settings, "UNIVERSAL_NOTIFICATIONS_TWILIO_MAX_RATE", 6)
19 |
20 |
21 | class NotificationHistory(models.Model):
22 | created = models.DateTimeField(auto_now_add=True)
23 | group = models.CharField(max_length=50)
24 | klass = models.CharField(max_length=255)
25 | receiver = models.CharField(max_length=255)
26 | details = models.TextField()
27 | category = models.CharField(max_length=255)
28 | content_type = models.ForeignKey(ContentType, null=True, on_delete=models.SET_NULL)
29 | object_id = models.PositiveIntegerField(null=True)
30 | source = GenericForeignKey("content_type", "object_id")
31 |
32 |
33 | class Device(models.Model):
34 | user = models.ForeignKey(AUTH_USER_MODEL, related_name="devices", on_delete=models.CASCADE)
35 | notification_token = models.TextField()
36 | device_id = models.CharField(max_length=255)
37 | is_active = models.BooleanField(default=True, help_text="Inactive devices will not be sent notifications")
38 | created = models.DateTimeField(auto_now_add=True)
39 | PLATFORM_IOS = "ios"
40 | PLATFORM_GCM = "gcm"
41 | PLATFORM_FCM = "fcm"
42 | PLATFORM_CHOICES = (
43 | (PLATFORM_IOS, "iOS"),
44 | (PLATFORM_GCM, "Google Cloud Messagging (deprecated)"),
45 | (PLATFORM_FCM, "Firebase Cloud Messaging"),
46 | )
47 | app_id = models.CharField(max_length=100)
48 | platform = models.CharField(max_length=10, choices=PLATFORM_CHOICES)
49 |
50 | def __unicode__(self):
51 | return "%s (%s)" % (self.user.email or "unknown user", self.device_id)
52 |
53 | def send_message(self, message, description="", **data):
54 | """Send message to device
55 |
56 | Args:
57 | message (string): Message string
58 | description (string): Optional description
59 | **data (dict, optional): Extra data
60 |
61 | Returns:
62 | boolean: status of sending notification
63 | """
64 | if not self.is_active:
65 | return False
66 |
67 | message = force_str(message)
68 | description = force_str(description)
69 | if self.platform == Device.PLATFORM_GCM:
70 | return gcm_send_message(self, message, data)
71 | elif self.platform == Device.PLATFORM_IOS:
72 | return apns_send_message(self, message, description, data)
73 | elif self.platform == Device.PLATFORM_FCM:
74 | return fcm_send_message(self, message, data)
75 | else:
76 | return False
77 |
78 |
79 | class Phone(models.Model):
80 | number = models.CharField(max_length=20, unique=True)
81 | rate = models.IntegerField("Messages rate", default=TWILIO_MAX_RATE)
82 | used_count = models.IntegerField(default=0)
83 |
84 | class Meta:
85 | ordering = ["number"]
86 |
87 | def __unicode__(self):
88 | return self.number
89 |
90 | def save(self, *args, **kwargs):
91 | self.number = format_phone(self.number)
92 | return super(Phone, self).save(*args, **kwargs)
93 |
94 |
95 | class PhoneReceiverManager(models.Manager):
96 |
97 | def format_fields(self, filters):
98 | for field in ["number", "service_number"]:
99 | if field in filters:
100 | try:
101 | filters[field] = format_phone(filters[field])
102 | except NumberParseException:
103 | raise PhoneReceiver.DoesNotExist
104 | return filters
105 |
106 | def filter(self, *args, **filters):
107 | filters = self.format_fields(filters)
108 | return super(PhoneReceiverManager, self).filter(*args, **filters)
109 |
110 | def get(self, **filters):
111 | filters = self.format_fields(filters)
112 | return super(PhoneReceiverManager, self).get(**filters)
113 |
114 |
115 | class PhoneReceiver(models.Model):
116 | number = models.CharField(max_length=20, db_index=True, unique=True)
117 | service_number = models.CharField(max_length=20, blank=True)
118 | is_blocked = models.BooleanField(default=False)
119 |
120 | objects = PhoneReceiverManager()
121 |
122 | class Meta:
123 | ordering = ["number"]
124 | index_together = (
125 | ("number", "service_number"),
126 | )
127 |
128 | def __unicode__(self):
129 | return self.number
130 |
131 | def save(self, *args, **kwargs):
132 | self.number = format_phone(self.number)
133 | self.service_number = format_phone(self.service_number)
134 | return super(PhoneReceiver, self).save(*args, **kwargs)
135 |
136 |
137 | class PhoneSent(models.Model):
138 | receiver = models.ForeignKey(PhoneReceiver, on_delete=models.CASCADE)
139 | text = models.TextField()
140 | sms_id = models.CharField(max_length=50, blank=True)
141 | STATUS_PENDING = "pending"
142 | STATUS_QUEUED = "queued"
143 | STATUS_FAILED = "failed"
144 | STATUS_SENT = "sent"
145 | STATUS_DELIVERED = "delivered"
146 | STATUS_UNDELIVERED = "undelivered"
147 | STATUS_NO_ANSWER = "no_answer"
148 | STATUS_CHOICES = (
149 | (STATUS_PENDING, "Pending"),
150 | (STATUS_QUEUED, "Queued"),
151 | (STATUS_FAILED, "failed"),
152 | (STATUS_SENT, "sent"),
153 | (STATUS_NO_ANSWER, "no answer from twilio"),
154 | (STATUS_DELIVERED, "delivered"),
155 | (STATUS_UNDELIVERED, "undelivered"),
156 | )
157 | status = models.CharField(max_length=35, choices=STATUS_CHOICES, default="pending")
158 | error_code = models.CharField(max_length=100, blank=True, null=True)
159 | error_message = models.TextField(blank=True, null=True)
160 | created = models.DateTimeField(auto_now_add=True)
161 | updated = models.DateTimeField(auto_now=True)
162 | media_raw = models.CharField(max_length=255, blank=True, null=True)
163 | media = models.CharField(max_length=255, blank=True, null=True)
164 |
165 | def send(self):
166 | if self.status not in [PhoneSent.STATUS_QUEUED, PhoneSent.STATUS_PENDING]:
167 | return
168 |
169 | from universal_notifications.backends.sms.base import SMS
170 | sms = SMS()
171 | sms.send(self)
172 |
173 | class Meta:
174 | verbose_name = "Sent Message"
175 | verbose_name_plural = verbose_name + "s"
176 |
177 |
178 | class PhoneReceivedRaw(models.Model):
179 | STATUS_PENDING = "pending"
180 | STATUS_PASS = "pass"
181 | STATUS_FAIL = "fail"
182 | STATUS_REJECTED = "rejected"
183 | STATUS_CHOICES = (
184 | (STATUS_PENDING, "Pending"),
185 | (STATUS_PASS, "Pass"),
186 | (STATUS_FAIL, "Fail"),
187 | (STATUS_REJECTED, "Rejected"),
188 | )
189 | status = models.CharField(max_length=35, choices=STATUS_CHOICES, default=STATUS_PENDING, db_index=True)
190 | data = JSONField()
191 | created = models.DateTimeField(auto_now_add=True)
192 | updated = models.DateTimeField(auto_now=True)
193 | exception = models.TextField(blank=True)
194 |
195 | def save(self, *args, **kwargs):
196 | from universal_notifications.tasks import parse_received_message_task
197 |
198 | super(PhoneReceivedRaw, self).save(*args, **kwargs)
199 | if self.status == PhoneReceivedRaw.STATUS_PENDING:
200 | parse_received_message_task.delay(self.id)
201 |
202 |
203 | class PhoneReceived(models.Model):
204 | TYPE_TEXT = "text"
205 | TYPE_VOICE = "voice"
206 | Type_choices = (
207 | (TYPE_VOICE, "voice"),
208 | (TYPE_TEXT, "Text"),
209 | )
210 | receiver = models.ForeignKey(PhoneReceiver, on_delete=models.CASCADE)
211 | text = models.TextField()
212 | media = models.CharField(max_length=255, blank=True, null=True)
213 | sms_id = models.CharField(max_length=50, blank=True)
214 | type = models.CharField(max_length=35, choices=Type_choices, default=TYPE_TEXT)
215 | created = models.DateTimeField(auto_now_add=True)
216 | updated = models.DateTimeField(auto_now=True)
217 | raw = models.ForeignKey(PhoneReceivedRaw, null=True, blank=True, editable=False, on_delete=models.SET_NULL)
218 | is_opt_out = models.BooleanField(default=False)
219 |
220 | class Meta:
221 | verbose_name = "Received Message"
222 | verbose_name_plural = verbose_name + "s"
223 |
224 |
225 | post_save.connect(phone_received_post_save, sender=PhoneReceived)
226 |
227 |
228 | class PhonePendingMessages(models.Model):
229 | created = models.DateTimeField(auto_now_add=True)
230 | from_phone = models.CharField(max_length=30, db_index=True)
231 | priority = models.IntegerField(default=9999)
232 | message = models.ForeignKey(PhoneSent, blank=True, null=True, on_delete=models.CASCADE)
233 |
234 | def save(self, *args, **kwargs):
235 | created = not self.id
236 | self.from_phone = format_phone(self.from_phone)
237 | ret = super(PhonePendingMessages, self).save(*args, **kwargs)
238 | if created:
239 | from universal_notifications.backends.sms.base import SMS
240 | sms = SMS()
241 | sms.add_to_queue(self)
242 | return ret
243 |
244 |
245 | class UnsubscribedUser(models.Model):
246 | user = models.ForeignKey(AUTH_USER_MODEL, on_delete=models.CASCADE)
247 | unsubscribed_from_all = models.BooleanField(default=False)
248 | unsubscribed = JSONField(default=dict)
249 |
--------------------------------------------------------------------------------
/universal_notifications/notifications.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | """Universal Notifications
3 |
4 | Sample usage:
5 | WSNotification(item, receivers, context).send()
6 |
7 | """
8 | import importlib
9 | import logging
10 | import re
11 | from email.utils import formataddr
12 |
13 | from django.conf import settings
14 | from django.contrib.contenttypes.models import ContentType
15 | from django.contrib.sites.models import Site
16 | from django.core.exceptions import ImproperlyConfigured
17 | from django.core.mail import EmailMessage
18 | from django.template import Context, Template
19 | from django.template.loader import get_template
20 | from premailer import Premailer
21 |
22 | from universal_notifications.backends.sms.utils import send_sms
23 | from universal_notifications.backends.websockets import publish
24 | from universal_notifications.models import Device, NotificationHistory, UnsubscribedUser
25 |
26 | logger = logging.getLogger(__name__)
27 |
28 | user_definitions = None
29 | if hasattr(settings, "UNIVERSAL_NOTIFICATIONS_USER_DEFINITIONS_FILE") and \
30 | hasattr(settings, "UNIVERSAL_NOTIFICATIONS_USER_CATEGORIES_MAPPING"):
31 | user_definitions = importlib.import_module(settings.UNIVERSAL_NOTIFICATIONS_USER_DEFINITIONS_FILE)
32 |
33 |
34 | class NotificationBase(object):
35 | check_subscription = True
36 | category = "default"
37 | PRIORITY_CATEGORY = "system" # this category will be always sent
38 |
39 | @classmethod
40 | def get_type(cls):
41 | raise NotImplementedError
42 |
43 | def __init__(self, item, receivers, context=None):
44 | self.item = item
45 | self.receivers = receivers
46 | self.context = context or {}
47 |
48 | @classmethod
49 | def get_mapped_user_notifications_types_and_categories(cls, user):
50 | """Returns a dictionary for given user type:
51 |
52 | {"notificaiton_type": [categries list]}
53 | TODO: use this one in serializer.
54 | """
55 | if not hasattr(settings, "UNIVERSAL_NOTIFICATIONS_USER_CATEGORIES_MAPPING"):
56 | notifications = {}
57 | for key in settings.UNIVERSAL_NOTIFICATIONS_CATEGORIES.keys():
58 | notifications[key] = settings.UNIVERSAL_NOTIFICATIONS_CATEGORIES[key].keys()
59 | return notifications
60 | else:
61 | for user_type in settings.UNIVERSAL_NOTIFICATIONS_USER_CATEGORIES_MAPPING:
62 | if getattr(user_definitions, user_type)(user):
63 | return settings.UNIVERSAL_NOTIFICATIONS_USER_CATEGORIES_MAPPING[user_type]
64 |
65 | def get_user_categories_for_type(self, user):
66 | """Check categories available for given user type and this notification type.
67 |
68 | If no mapping present we assume all are allowed.
69 | Raises ImproperlyConfigured if no categories for given user availaible
70 | """
71 | categories = self.get_mapped_user_notifications_types_and_categories(user)
72 | if categories:
73 | return categories[self.get_type().lower()]
74 |
75 | raise ImproperlyConfigured(
76 | "UNIVERSAL NOTIFICATIONS USER CATEGORIES MAPPING: No categories for given user: %s" % user)
77 |
78 | def get_context(self):
79 | context = self.context
80 | context["item"] = self.item
81 | return context
82 |
83 | def prepare_receivers(self):
84 | raise NotImplementedError
85 |
86 | def prepare_message(self):
87 | raise NotImplementedError
88 |
89 | def send_inner(self, prepared_receivers, prepared_message):
90 | raise NotImplementedError
91 |
92 | def get_notification_history_details(self):
93 | raise NotImplementedError
94 |
95 | def format_receiver_for_notification_history(self, receiver):
96 | return receiver
97 |
98 | def check_category(self):
99 | if self.category == self.PRIORITY_CATEGORY or not self.check_subscription:
100 | return
101 | if not self.category:
102 | raise ImproperlyConfigured("Category is required", self)
103 |
104 | notification_type = self.get_type().lower()
105 | if not hasattr(settings, "UNIVERSAL_NOTIFICATIONS_CATEGORIES"):
106 | raise ImproperlyConfigured("Please define UNIVERSAL_NOTIFICATIONS_CATEGORIES in your settings.py")
107 |
108 | categories = settings.UNIVERSAL_NOTIFICATIONS_CATEGORIES.get(notification_type, {})
109 | if self.category not in categories.keys():
110 | raise ImproperlyConfigured("No such category for Universal Notifications: %s: %s." % (
111 | self.get_type(), self.category))
112 | # check if user is allowed to get notifications from this category
113 | for user in self.receivers:
114 | if self.category not in self.get_user_categories_for_type(user):
115 | raise ImproperlyConfigured(
116 | "User is not allowed to receive notifications from '%s:%s' category"
117 | % (self.get_type(), self.category))
118 |
119 | def verify_and_filter_receivers_subscriptions(self):
120 | """Returns new list of only receivers that are subscribed for given notification type/category."""
121 | if not self.check_subscription or self.category == self.PRIORITY_CATEGORY:
122 | return self.receivers
123 |
124 | receivers_ids = (x.id for x in self.receivers)
125 | unsubscribed_map = {}
126 | for unsubscribed_user in UnsubscribedUser.objects.filter(user__in=receivers_ids):
127 | unsubscribed_map[unsubscribed_user.user_id] = unsubscribed_user
128 |
129 | filtered_receivers = []
130 | ntype = self.get_type().lower()
131 | for receiver in self.receivers:
132 | unsubscribed_user = unsubscribed_map.get(receiver.id, None)
133 | if unsubscribed_user:
134 | if unsubscribed_user.unsubscribed_from_all:
135 | continue
136 | unsubscribed = unsubscribed_user.unsubscribed.get(ntype, {})
137 | if "all" in unsubscribed or self.category in unsubscribed:
138 | continue
139 | filtered_receivers.append(receiver)
140 | self.receivers = filtered_receivers
141 |
142 | def save_notifications(self, prepared_receivers):
143 | for receiver in prepared_receivers:
144 | data = {
145 | "group": self.get_type(),
146 | "klass": self.__class__.__name__,
147 | "receiver": self.format_receiver_for_notification_history(receiver),
148 | "details": self.get_notification_history_details(),
149 | "category": self.category,
150 | }
151 |
152 | if hasattr(self.item, "id"):
153 | if isinstance(self.item.id, int):
154 | content_type = ContentType.objects.get_for_model(self.item)
155 | data["content_type"] = content_type
156 | data["object_id"] = self.item.id
157 |
158 | if getattr(settings, "UNIVERSAL_NOTIFICATIONS_HISTORY", True):
159 | if getattr(settings, "UNIVERSAL_NOTIFICATIONS_HISTORY_USE_DATABASE", True):
160 | NotificationHistory.objects.create(**data)
161 |
162 | logger.info("Notification sent: {}".format(data))
163 |
164 | def send(self):
165 | self.check_category()
166 | self.verify_and_filter_receivers_subscriptions()
167 | prepared_receivers = self.prepare_receivers()
168 | prepared_message = self.prepare_message()
169 | result = self.send_inner(prepared_receivers, prepared_message)
170 | self.save_notifications(prepared_receivers)
171 | return result
172 |
173 |
174 | class WSNotification(NotificationBase):
175 | message = None # required
176 | serializer_class = None # required, DRF serializer
177 | serializer_many = False
178 | check_subscription = False
179 |
180 | def prepare_receivers(self):
181 | return set(self.receivers)
182 |
183 | def prepare_message(self):
184 | return {
185 | "message": self.message,
186 | "data": self.serializer_class(self.item, context=self.get_context(), many=self.serializer_many).data
187 | }
188 |
189 | def format_receiver_for_notification_history(self, receiver):
190 | return receiver.email
191 |
192 | def send_inner(self, prepared_receivers, prepared_message):
193 | for receiver in prepared_receivers:
194 | publish(receiver, additional_data=prepared_message)
195 |
196 | def get_notification_history_details(self):
197 | return "message: %s, serializer: %s" % (self.message, self.serializer_class.__name__)
198 |
199 | @classmethod
200 | def get_type(cls):
201 | return "WebSocket"
202 |
203 |
204 | class SMSNotification(NotificationBase):
205 | message = None # required, django template string
206 | send_async = getattr(settings, "UNIVERSAL_NOTIFICATIONS_SMS_SEND_IN_TASK", True)
207 |
208 | def prepare_receivers(self):
209 | """Filter out duplicated phone numbers"""
210 | receivers = set()
211 | phone_numbers = set()
212 | for r in self.receivers:
213 | if r.phone not in phone_numbers:
214 | receivers.add(r)
215 |
216 | return receivers
217 |
218 | def prepare_message(self):
219 | return Template(self.message).render(Context(self.get_context()))
220 |
221 | def send_inner(self, prepared_receivers, prepared_message):
222 | for receiver in prepared_receivers:
223 | self.context["receiver"] = receiver
224 | send_sms(receiver.phone, self.prepare_message(), send_async=self.send_async)
225 |
226 | def get_notification_history_details(self):
227 | return self.prepare_message()
228 |
229 | @classmethod
230 | def get_type(cls):
231 | return "SMS"
232 |
233 |
234 | class EmailNotification(NotificationBase):
235 | """Email notification
236 |
237 | Attributes:
238 | email_name required
239 | email_subject if not provided, will try to extract "" tag from email template
240 | sender optional sender
241 | categories optional categories which are added to EmailMessage (can be used with SendGrid)
242 | sendgrid_asm SendGrid unsubscribe groups configuration, available properties:
243 | * group_id - ID of an unsubscribe group
244 | * groups_to_display - Unsubscribe groups to display
245 | """
246 | email_name = None # required
247 | email_subject = None # if not provided, will try to extract "<title>" tag from email template
248 | sender = None # optional
249 | categories = [] # optional
250 | sendgrid_asm = {}
251 | use_premailer = None
252 |
253 | def __init__(self, item, receivers, context=None, attachments=None):
254 | self.attachments = attachments or []
255 | super(EmailNotification, self).__init__(item, receivers, context)
256 |
257 | @classmethod
258 | def format_receiver(cls, receiver):
259 | receiver_name = "%s %s" % (receiver.first_name, receiver.last_name)
260 | receiver_name = re.sub(r"\S*@\S*\s?", "", receiver_name).strip()
261 | return formataddr((receiver_name, receiver.email))
262 |
263 | def prepare_receivers(self):
264 | return set(self.receivers)
265 |
266 | def prepare_message(self):
267 | return self.get_context()
268 |
269 | def format_receiver_for_notification_history(self, receiver):
270 | return receiver.email
271 |
272 | def prepare_subject(self):
273 | if self.email_subject:
274 | return Template(self.email_subject).render(Context(self.get_context()))
275 |
276 | def get_notification_history_details(self):
277 | return self.email_name
278 |
279 | @classmethod
280 | def get_type(cls):
281 | return "Email"
282 |
283 | def get_full_template_context(self):
284 | is_secure = getattr(settings, "UNIVERSAL_NOTIFICATIONS_IS_SECURE", False)
285 | protocol = "https://" if is_secure else "http://"
286 | site = Site.objects.get_current()
287 | return {
288 | "site": site,
289 | "STATIC_URL": settings.STATIC_URL,
290 | "is_secure": is_secure,
291 | "protocol": protocol,
292 | "domain": site.domain
293 | }
294 |
295 | def get_template(self):
296 | return get_template("emails/email_%s.html" % self.email_name)
297 |
298 | def send_email(self, subject, context, receiver):
299 | template = self.get_template()
300 | html = template.render(context)
301 | # update paths
302 | base = context["protocol"] + context["domain"]
303 | sender = self.sender or settings.DEFAULT_FROM_EMAIL
304 | if getattr(settings, "UNIVERSAL_NOTIFICATIONS_USE_PREMAILER", True) and self.use_premailer is not False:
305 | html = html.replace("{settings.STATIC_URL}CACHE/".format(settings=settings),
306 | "{settings.STATIC_ROOT}/CACHE/".format(settings=settings)) # get local file
307 | html = Premailer(html,
308 | remove_classes=False,
309 | exclude_pseudoclasses=False,
310 | keep_style_tags=True,
311 | include_star_selectors=True,
312 | strip_important=False,
313 | cssutils_logging_level=logging.CRITICAL,
314 | base_url=base).transform()
315 |
316 | # if subject is not provided, try to extract it from <title> tag
317 | if not subject:
318 | self.email_subject = self.__get_title_from_html(html)
319 | subject = self.prepare_subject()
320 |
321 | email = EmailMessage(subject, html, sender, [receiver], attachments=self.attachments)
322 | if self.categories:
323 | email.categories = self.categories
324 |
325 | if self.sendgrid_asm:
326 | email.asm = self.sendgrid_asm
327 |
328 | email.content_subtype = "html"
329 | email.send(fail_silently=False)
330 |
331 | def send_inner(self, prepared_receivers, prepared_message):
332 | subject = self.email_subject
333 | if subject:
334 | subject = self.prepare_subject()
335 |
336 | context = self.get_full_template_context()
337 | context.update(prepared_message)
338 | for receiver in prepared_receivers:
339 | context["receiver"] = receiver
340 | self.send_email(subject, context, self.format_receiver(receiver))
341 |
342 | def __get_title_from_html(self, html):
343 | m = re.search(r"<title>(.*?)", html, re.MULTILINE | re.IGNORECASE)
344 | if not m:
345 | raise ImproperlyConfigured("Email notification {} does not provide email_subject nor "
346 | " in the template".format(self.email_name))
347 |
348 | return m.group(1)
349 |
350 |
351 | class PushNotification(NotificationBase):
352 | title = None # required, django template string
353 | description = "" # optional, django template string
354 |
355 | @classmethod
356 | def get_type(cls):
357 | return "Push"
358 |
359 | def prepare_receivers(self):
360 | return set(self.receivers)
361 |
362 | def prepare_body(self): # self.item & self.context can be used here
363 | return {}
364 |
365 | def prepare_message(self):
366 | context = Context(self.get_context())
367 | return {
368 | "title": Template(self.title).render(context),
369 | "description": Template(self.description).render(context),
370 | "data": self.prepare_body()
371 | }
372 |
373 | def format_receiver_for_notification_history(self, receiver):
374 | return receiver.email
375 |
376 | def send_inner(self, prepared_receivers, prepared_message): # TODO
377 | for receiver in prepared_receivers:
378 | for d in Device.objects.filter(user=receiver, is_active=True):
379 | d.send_message(prepared_message["title"], prepared_message["description"], **prepared_message["data"])
380 |
381 | def get_notification_history_details(self):
382 | return self.prepare_message()
383 |
--------------------------------------------------------------------------------
/universal_notifications/serializers.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.conf import settings
3 | from rest_framework import serializers
4 |
5 | from universal_notifications.models import Device
6 | from universal_notifications.notifications import NotificationBase
7 |
8 |
9 | class DeviceSerializer(serializers.ModelSerializer):
10 |
11 | def create(self, data):
12 | data["user"] = self.context["request"].user
13 |
14 | # do not allow duplicating devices
15 | matching_device = data["user"].devices.filter(
16 | is_active=True, notification_token=data["notification_token"]).first()
17 | if matching_device:
18 | self.context["view"]._matching_device = matching_device
19 | return matching_device
20 |
21 | return super(DeviceSerializer, self).create(data)
22 |
23 | class Meta:
24 | model = Device
25 | fields = ["id", "platform", "notification_token", "device_id", "app_id"]
26 |
27 |
28 | class UnsubscribedSerializer(serializers.Serializer):
29 | unsubscribed_from_all = serializers.BooleanField(required=False)
30 |
31 | def get_configuration(self):
32 | request = self.context.get("request", None)
33 | if request and request.user.is_authenticated:
34 | return NotificationBase.get_mapped_user_notifications_types_and_categories(request.user)
35 | return None
36 |
37 | def to_representation(self, obj):
38 | result = {
39 | "unsubscribed_from_all": obj.unsubscribed_from_all,
40 | "labels": {}
41 | }
42 |
43 | configuration = self.get_configuration()
44 | if configuration:
45 | for ntype, ntype_configuration in configuration.items():
46 | type_unsubscribed = set(obj.unsubscribed.get(ntype, []))
47 | result["labels"][ntype] = {}
48 | result[ntype] = {
49 | "unsubscribed_from_all": "all" in type_unsubscribed
50 | }
51 | for key in ntype_configuration:
52 | result[ntype][key] = key not in type_unsubscribed
53 | result["labels"][ntype][key] = settings.UNIVERSAL_NOTIFICATIONS_CATEGORIES[ntype][key]
54 |
55 | return result
56 |
57 | def validate(self, data):
58 | """ validation actually maps categories data & adds them to validated data"""
59 | request = self.context.get("request", None)
60 | unsubscribed = {}
61 | data["unsubscribed"] = unsubscribed
62 |
63 | configuration = self.get_configuration()
64 | if configuration:
65 | for ntype, ntype_configuration in configuration.items():
66 | unsubscribed[ntype] = []
67 | if ntype in request.data:
68 | for key in ntype_configuration:
69 | if not request.data[ntype].get(key, True):
70 | unsubscribed[ntype].append(key)
71 | if request.data[ntype].get("unsubscribed_from_all", False):
72 | unsubscribed[ntype].append("all")
73 |
74 | return data
75 |
76 | def update(self, instance, data):
77 | for key, value in data.items():
78 | setattr(instance, key, value)
79 | return instance
80 |
--------------------------------------------------------------------------------
/universal_notifications/signals.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import django.dispatch
3 |
4 | ws_received = django.dispatch.Signal()
5 |
--------------------------------------------------------------------------------
/universal_notifications/tasks.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | import traceback
3 |
4 | import six
5 | from django.conf import settings
6 |
7 | from universal_notifications.backends.sms.base import SMS
8 | from universal_notifications.backends.sms.utils import clean_text
9 | from universal_notifications.models import PhonePendingMessages, PhoneReceivedRaw, PhoneReceiver, PhoneSent
10 | from universal_notifications.signals import ws_received
11 |
12 | try:
13 | from django.utils.importlib import import_module
14 | except ImportError:
15 | from importlib import import_module
16 |
17 | CELERY_APP_PATH = getattr(settings, "CELERY_APP_PATH", False)
18 |
19 | if CELERY_APP_PATH:
20 | __path, __symbol = CELERY_APP_PATH.rsplit(".", 1)
21 | app = getattr(import_module(__path), __symbol)
22 |
23 | @app.task(ignore_result=True)
24 | def parse_received_message_task(message_id):
25 | try:
26 | raw = PhoneReceivedRaw.objects.get(id=message_id, status=PhoneReceivedRaw.STATUS_PENDING)
27 | except PhoneReceivedRaw.DoesNotExist:
28 | return
29 |
30 | try:
31 | sms = SMS()
32 | if sms.parse_received(raw):
33 | raw.status = PhoneReceivedRaw.STATUS_PASS
34 | raw.save()
35 | except Exception:
36 | raw.status = PhoneReceivedRaw.STATUS_FAIL
37 | raw.exception = traceback.format_exc()
38 | raw.save()
39 |
40 | @app.task(ignore_result=True)
41 | def send_message_task(to_number, text, media, priority):
42 | sms = SMS()
43 |
44 | try:
45 | receiver = PhoneReceiver.objects.get(number=to_number)
46 | except PhoneReceiver.DoesNotExist:
47 | service_number = sms.get_service_number()
48 | receiver = PhoneReceiver.objects.create(number=to_number, service_number=service_number)
49 |
50 | obj = PhoneSent()
51 | obj.receiver = receiver
52 | obj.text = six.text_type(clean_text(text))
53 | obj.media_raw = media
54 | obj.status = PhoneSent.STATUS_QUEUED
55 |
56 | if receiver.is_blocked:
57 | obj.status = PhoneSent.STATUS_FAILED
58 | obj.save()
59 | return
60 |
61 | obj.save()
62 |
63 | data = {
64 | "from_phone": obj.receiver.service_number,
65 | "priority": priority,
66 | "message": obj,
67 | }
68 | PhonePendingMessages.objects.create(**data)
69 |
70 | @app.task(ignore_result=True)
71 | def ws_received_send_signal_task(message_data, channel_emails):
72 | ws_received.send(sender=None, message_data=message_data, channel_emails=channel_emails)
73 |
--------------------------------------------------------------------------------
/universal_notifications/templates/emails/email_test.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | Email template used in tests
6 |
7 |
8 | This is some email
9 |
10 |
11 |
--------------------------------------------------------------------------------
/universal_notifications/templates/emails/email_test_empty.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
--------------------------------------------------------------------------------
/universal_notifications/templates/emails/fake.html:
--------------------------------------------------------------------------------
1 | {% if template and email %}
2 | {% if template_does_not_exist %}
3 | Template "emails/email_{{template}}.html" does not exist!
4 | {% else %}
5 | Sent email "{{ template }}" to: {{ email }}
6 | {% endif %}
7 | {% else %}
8 | {% if not template %}
9 | GET param "template" is required. eg. for emails/email_reset_password_content.html set ?template=reset_password_content
10 | {% endif %}
11 | {% if not email %}
12 | Please set email in settings variable UNIVERSAL_NOTIFICATIONS_FAKE_EMAIL_TO
13 | {% endif %}
14 | {% endif %}
15 |
--------------------------------------------------------------------------------
/universal_notifications/urls.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | from django.urls import include, re_path
3 | from rest_framework.routers import DefaultRouter
4 |
5 | urlpatterns = [
6 | re_path(r"^emails/", include("universal_notifications.backends.emails.urls")),
7 | re_path(r"api/", include("universal_notifications.api_urls")),
8 | ]
9 |
10 | router = DefaultRouter()
11 | urlpatterns += router.urls
12 |
--------------------------------------------------------------------------------