def send_fcm_notification(title="", body="", data=None, users=None):
"""
sends fcm notification to a single or multiple user device
:param title: title of the notification message
:param body: body of the notification
:param data: any data to be sent
:param users: list of user ids
:return: True/False
"""
if users:
push_service = FCMNotification(api_key=settings.FCM_API_KEY)
try:
if data:
if isinstance(users, list):
registration_ids = [
devices.registration_id
for devices in UserDevice.objects.filter(
used_id__in=users)
]
push_service.multiple_devices_data_message(
registration_ids=registration_ids, data_message=data)
else:
registration_id = UserDevice.objects.get(
user_id=users).registration_id
push_service.single_device_data_message(
registration_id=registration_id, data_message=data)
else:
if isinstance(users, list):
registration_ids = [
devices.registration_id
for devices in UserDevice.objects.filter(
user_id__in=users)
]
push_service.notify_multiple_devices(
registration_ids=registration_ids,
message_title=title,
message_body=body)
else:
registration_id = UserDevice.objects.get(
user_id=users).registration_id
push_service.notify_single_device(
registration_id=registration_id,
message_title=title,
message_body=body)
return True
except:
return False
else:
return False
def nueva(solicitud, lectura):
peaje = lectura.peaje
alerta = Alerta.objects.create(lectura=lectura)
mensaje = {
'alerta_id': alerta.pk,
'latitud': str(peaje.latitud),
'longitud': str(peaje.longitud),
'radio': str(peaje.radio)
}
registration_ids = []
patrulleros = Patrullero.objects.filter(activo=True)
for patrullero in patrulleros:
registration_ids.append(patrullero.token)
push_service = FCMNotification(
api_key="AIzaSyBCr-rmINKdZQUKT3rQmLolkeFX4iNaB7c")
result = push_service.multiple_devices_data_message(
registration_ids=registration_ids, data_message=mensaje)
if result['success'] == 1:
for patrullero in patrulleros:
Notificacion.objects.create(alerta=alerta,
patrullero=patrullero)
else:
Alerta.objects.filter(pk=alerta.pk).delete()
alerta = None
print("\nError al enviar las notificaciones\n")
print(result)
return alerta
def perform_create(self, request, serializer):
recipients_array = []
registration_ids = []
recipients = []
instance_message = master_data_models.Message()
message_date_time = serializer.data['message_date_time']
creator = serializer.data['creator']
message_body = serializer.data['message_body']
subject = serializer.data['subject']
parent_message_id = serializer.data['parent_message_id']
instance_message.message_date_time = message_date_time
instance_message.creator_id = creator
instance_message.message_body = message_body
instance_message.subject = subject
instance_message.parent_message_id = parent_message_id
instance_message.save()
for val in serializer.data["message_recipients"]:
is_read = val["is_read"]
recipient = val["recipient"]
recipients.append(recipient)
instance_message_recipients = master_data_models.MessageRecipient()
instance_message_recipients.is_read = is_read
instance_message_recipients.message_id = instance_message.id
instance_message_recipients.recipient_id = recipient
instance_message_recipients.save()
recipients_object = {"id": instance_message_recipients.id, "is_read": "false",
"message_id": instance_message.id,
"recipient": recipient}
recipients_array.append(recipients_object)
message_object = {"message_date_time": message_date_time, "creator": creator, "id": instance_message.id,
"message_body": "" + message_body + "", "message_recipients": recipients_array,
"parent_message_id": parent_message_id, "subject": "" + subject + ""}
message_payload = {"type": "NEW_MESSAGE", "data": message_object}
# Send the newly created message and recipients to firebase
fcm_tokens = user_management_models.Profile.objects.filter(user_id__in=recipients)
push_service = FCMNotification(api_key=settings.FCM_APIKEY)
for x in fcm_tokens:
registration_ids.append(""+x.reg_id+"")
result = push_service.multiple_devices_data_message(registration_ids=registration_ids,
data_message=message_payload)
print(result)
return message_payload
def send_user_a_push_notification(request):
registration_ids = []
if request.method == "POST":
recipients = request.POST["recipients"].split(',')
form = ComposeMessageForm(request.POST)
if form.is_valid():
form.full_clean()
instance = form.save(commit=False)
instance.message_date_time = datetime.now().timestamp()
instance.creator = request.user
instance.save()
# Message object elements
recipients_array = []
message_time_stamp = int(datetime.now().timestamp()) * 1000
creator_id = request.user.id
message_body = form.cleaned_data['message_body']
subject = form.cleaned_data['subject']
message_id = instance.id
for x in range(len(recipients)):
instance_message_recipients = master_data_models.MessageRecipient()
instance_message_recipients.message_id = instance.id
instance_message_recipients.recipient_id = recipients[x]
instance_message_recipients.save()
recipients_object = {"id":instance_message_recipients.id, "is_read": "false", "message_id": message_id,
"recipient": recipients[x]}
recipients_array.append(recipients_object)
message_object = {"message_date_time": message_time_stamp, "creator": creator_id, "id": message_id,
"message_body": "" + message_body + "", "message_recipients": recipients_array,
"parent_message_id": 0, "subject": "" + subject + ""}
message_payload = {"type": "NEW_MESSAGE", "data": message_object}
# Send the newly created message and recipients to firebase
fcm_tokens = user_management_models.Profile.objects.filter(user_id__in=recipients)
push_service = FCMNotification(api_key=settings.FCM_APIKEY)
for x in fcm_tokens:
# if x.reg_id is not None:
# x.send_message(json.dumps(message_payload))
registration_ids.append("" + x.reg_id + "")
result = push_service.multiple_devices_data_message(registration_ids=registration_ids,
data_message=message_payload)
return redirect(request.META['HTTP_REFERER'])
def update(self, request, *args, **kwargs):
serializer = self.get_serializer(data=request.data)
message_recipient = request.data.get("id")
deleted_from_mail_box = request.data.get("deleted_from_mail_box")
recipient_array = []
registration_ids = []
if serializer.is_valid:
queryset = master_data_models.MessageRecipient.objects.all()
instance = queryset.get(id=message_recipient)
instance.deleted_from_mail_box = deleted_from_mail_box
instance.save()
query_all_recipients = master_data_models.MessageRecipient.objects.filter(
message_id=instance.message_id)
for x in query_all_recipients:
recipients_object = {"id": message_recipient, "deleted_from_mail_box": deleted_from_mail_box,
"message_id": instance.message_id,
"recipient": x.recipient_id}
recipient_array.append(recipients_object)
# Send the newly created message and recipients to firebase
query_message_recipients = master_data_models.MessageRecipient.objects.filter \
(message_id=instance.message_id).values("recipient_id")
query_message = master_data_models.Message.objects.get(id=instance.message_id)
creator_id = query_message.creator_id
fcm_tokens = user_management_models.Profile.objects.filter(user_id__in=query_message_recipients)
# creator_fcm_token = user_management_models.Profile.objects.get(user_id=creator_id)
message_payload = {"type": "NEW_MESSAGE",
"data": recipient_array}
# Send notification to creator
# creator_fcm_token.send_message(json.dumps(message_payload))
# Send the newly created message and recipients to firebase
push_service = FCMNotification(api_key=settings.FCM_APIKEY)
for x in fcm_tokens:
registration_ids.append("" + x.reg_id + "")
result = push_service.multiple_devices_data_message(registration_ids=registration_ids,
data_message=message_payload)
print(result)
return Response("Success.", status=status.HTTP_200_OK)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def send_thread_message(request):
if request.method == "POST":
message_id = request.POST["message_id"]
message = request.POST["message"]
registration_ids = []
recipients_array = []
message_time_stamp = int(datetime.now().timestamp()) * 1000
instance = master_data_models.Message()
instance.message_date_time = datetime.now().timestamp()
instance.message_body = message
instance.parent_message_id = message_id
instance.creator_id = request.user.id
instance.save()
query_parent_recipients = master_data_models.MessageRecipient.objects.filter(message_id=message_id)
for x in query_parent_recipients:
instance_recipients = master_data_models.MessageRecipient()
instance_recipients.message_id = instance.id
instance_recipients.recipient_id = x.recipient_id
instance_recipients.save()
recipients_array.append(x.recipient_id)
# insert the creator as a recipient too
query_original_message = master_data_models.Message.objects.get(id=message_id, parent_message_id=0)
instance_recipients = master_data_models.MessageRecipient()
instance_recipients.message_id = instance.id
instance_recipients.recipient_id = query_original_message.creator_id
instance_recipients.save()
message_object = {"message_date_time": message_time_stamp, "creator": request.user.id, "id": message_id,
"message_body": "" + message + "", "message_recipients": recipients_array,
"parent_message_id": message_id, "subject": ""}
message_payload = {"type": "THREAD_MESSAGE", "data": message_object}
# Send the newly created message and recipients to firebase
recipients = master_data_models.MessageRecipient.objects.filter(message_id=message_id).values("recipient")
fcm_tokens = user_management_models.Profile.objects.filter(user_id__in=recipients)
push_service = FCMNotification(api_key=settings.FCM_APIKEY)
for x in fcm_tokens:
registration_ids.append("" + x.reg_id + "")
result = push_service.multiple_devices_data_message(registration_ids=registration_ids,
data_message=message_payload)
return redirect(request.META['HTTP_REFERER'])
def send_notify(title, message, action, payload):
push_service = FCMNotification(api_key=API_KEY)
# OR initialize with proxies
# proxy_dict = {
# "http" : "http://127.0.0.1",
# "https" : "http://127.0.0.1",
# }
# push_service = FCMNotification(api_key="<api-key>", proxy_dict=proxy_dict)
# Your api-key can be gotten from: https://console.firebase.google.com/project/<project-name>/settings/cloudmessaging
# registration_id = "dHgoSI8XRc-b4oqhGiOHgu:APA91bEQVjg-ZEYOyT2LqGZGkwuE4mQStwk7wSMBWJPpqxIterzzftnleW7SQuCRspdfoIxT1E2zGcExJettfZXj9K5dtHWj8gCop3A8yfwY1XoACXmvMqhKNVV704YtEgkt345W8xNp"
# result = push_service.notify_single_device(registration_id=registration_id,
# message_title=title,
# message_body=message)
# Send to multiple devices by passing a list of ids.
registration_ids = device.get_all_device_id()
# Sending a notification with data message payload
data_message = {
"title": title,
"message": message,
"action": action,
"payload": payload
}
# To multiple devices
result = push_service.multiple_devices_data_message(
registration_ids=registration_ids, data_message=data_message)
print(result)
return result
def fcm_send_bulk_data_messages(api_key,
registration_ids=None,
condition=None,
collapse_key=None,
delay_while_idle=False,
time_to_live=None,
restricted_package_name=None,
low_priority=False,
dry_run=False,
data_message=None,
content_available=None,
timeout=5,
json_encoder=None):
"""
Arguments correspond to those from pyfcm/fcm.py.
Sends push message to multiple devices,
can send to over 1000 devices
Args:
api_key
registration_ids (list): FCM device registration IDs.
data_message (dict): Data message payload to send alone or with the notification message
Keyword Args:
collapse_key (str, optional): Identifier for a group of messages
that can be collapsed so that only the last message gets sent
when delivery can be resumed. Defaults to ``None``.
delay_while_idle (bool, optional): If ``True`` indicates that the
message should not be sent until the device becomes active.
time_to_live (int, optional): How long (in seconds) the message
should be kept in FCM storage if the device is offline. The
maximum time to live supported is 4 weeks. Defaults to ``None``
which uses the FCM default of 4 weeks.
low_priority (boolean, optional): Whether to send notification with
the low priority flag. Defaults to ``False``.
restricted_package_name (str, optional): Package name of the
application where the registration IDs must match in order to
receive the message. Defaults to ``None``.
dry_run (bool, optional): If ``True`` no message will be sent but
request will be tested.
Returns:
:tuple:`multicast_id(long), success(int), failure(int), canonical_ids(int), results(list)`:
Response from FCM server.
Raises:
AuthenticationError: If :attr:`api_key` is not set or provided or there is an error authenticating the sender.
FCMServerError: Internal server error or timeout error on Firebase cloud messaging server
InvalidDataError: Invalid data provided
InternalPackageError: JSON parsing error, mostly from changes in the response of FCM, create a new github issue to resolve it.
"""
push_service = FCMNotification(
api_key=SETTINGS.get("FCM_SERVER_KEY") if api_key is None else api_key,
json_encoder=json_encoder,
)
return push_service.multiple_devices_data_message(
registration_ids=registration_ids,
condition=condition,
collapse_key=collapse_key,
delay_while_idle=delay_while_idle,
time_to_live=time_to_live,
restricted_package_name=restricted_package_name,
low_priority=low_priority,
dry_run=dry_run,
data_message=data_message,
content_available=content_available,
timeout=timeout)
class fcm(object):
def __init__(self, config):
self.config = config
self.api_key = self.config.get('api_key')
# FCM guarantees best-effort delivery with TTL 0
self.ttl = self.config.get('ttl', 0)
self.timeout = self.config.get('timeout', 10)
self.default_notification = self.config.get('notification_title')
self.proxy = None
if 'proxy' in self.config:
host = self.config['proxy']['host']
port = self.config['proxy']['port']
self.proxy = {
'http': 'http://%s:%s' % (host, port),
'https': 'https://%s:%s' % (host, port)
}
self.client = FCMNotification(api_key=self.api_key,
proxy_dict=self.proxy)
def send_push(self, message):
# Tracking message have no target, skip sending push notification
if 'target' not in message:
return
connection = db.engine.raw_connection()
cursor = connection.cursor()
cursor.execute(
'''SELECT `registration_id`, `platform`
FROM `device` WHERE `user_id` =
(SELECT `id` FROM `target` WHERE `name` = %s
AND `type_id` = (SELECT `id` FROM `target_type` WHERE `name` = 'user'))''',
message['target'])
registration_ids = cursor.fetchall()
android_ids = [
row[0] for row in registration_ids if row[1] == 'Android'
]
ios_ids = [row[0] for row in registration_ids if row[1] == 'iOS']
invalid_ids = []
failed_ids = []
# Handle iOS and Android ids separately. Mobile app requires different formats for
# correct behavior on both platforms (esp with respect to action buttons)
if ios_ids:
try:
data_message = {'incident_id': message.get('incident_id')}
response = self.client.notify_multiple_devices(
registration_ids=ios_ids,
message_title=message.get('subject',
self.default_notification),
message_body=message.get('body', ''),
sound='default',
time_to_live=self.ttl,
data_message=data_message,
timeout=self.timeout,
click_action='incident')
for idx, result in enumerate(response['results']):
error = result.get('error')
if error == 'NotRegistered':
invalid_ids.append(ios_ids[idx])
elif error is not None:
failed_ids.append((ios_ids[idx], error))
except Exception:
logger.exception('FCM request failed for message id %s',
message.get('message_id'))
if android_ids:
try:
data_message = {
'incident_id':
message.get('incident_id'),
'title':
message.get('subject', self.default_notification),
'message':
message.get('body', ''),
'actions': [{
'title': 'Claim',
'callback': 'claimIncident',
'foreground': True
}]
}
response = self.client.multiple_devices_data_message(
registration_ids=android_ids,
time_to_live=self.ttl,
data_message=data_message,
timeout=self.timeout)
for idx, result in enumerate(response['results']):
error = result.get('error')
if error == 'NotRegistered':
invalid_ids.append(android_ids[idx])
elif error is not None:
failed_ids.append((android_ids[idx], error))
except Exception:
logger.exception('FCM request failed for message id %s',
message.get('message_id'))
# Clean invalidated push notification IDs
if invalid_ids:
cursor.execute(
'''DELETE FROM `device` WHERE `registration_id` IN %s''',
(invalid_ids, ))
connection.commit()
if failed_ids:
logger.exception('FCM requests failed: %s', failed_ids)
cursor.close()
connection.close()
# FCM Notification을 위한 모듈. 원랜 firebase 측으로 HTTP request를 전송해야 하지만
# 어떤 개발자가 이게 불편하다고 느꼈는지 pyfcm을 만들어 두었다
fcm = FCMNotification(api_key='')
# FCM 서버 키를 통해 객체를 만들자
# 클라이언트 하나에 보내기, 여러 곳에 보내기, topic subscriber에 보내기가 대표적인 메소드다
fcm.notify_single_device(registration_id='',
message_title='제목이야',
message_body='body다')
fcm.notify_multiple_devices(registration_ids=['', ''],
message_title='제-목',
message_body='배고파')
# 여러 클라이언트에 보내는 메소드. registration_ids 파라미터로 리스트 형태의 클라이언트 키들을 전달한다
fcm.notify_topic_subscribers(topic_name='',
message_title='제-목',
message_body='body!')
# 특정 topic을 subscribe하고 있는 디바이스에 보내기
# fcm 푸쉬 메시지는 data message를 전송할 수 있다. 일반적으로 JSON이며 pyfcm 측에서는 data_message 인자로 딕셔너리를 전달하면 알아서 직렬화 처리해준다
data = {'key1': 123, 'key2': 1234}
fcm.notify_single_device(registration_id='', data_message=data)
# notify_*** 메소드에도 data_message 파라미터가 있지만, pyfcm 측에서 data messaging을 위한 메소드를 만들어 두었다
fcm.single_device_data_message(registration_id='', data_message=data)
fcm.multiple_devices_data_message(registration_ids=['', '', ''],
data_message=data)
class Helpers:
def __init__(self, flask_app):
self.logger = flask_app.logger
apikey = "AAAAgOfyS6s:APA91bH0GGnd4Xvw_pWMDpGmsQrR79CU8_bOmDj2QsHyrpua89dwV_UUAcJNRELByd_uikq4Hd5oI-ik6uWoW9i4w3qgtdqqg8TYKwwhAg-HllaBKoIdAy9yF1tvIGaAUvXGLtdIzTqF" # api key from FCM for the app
self.push_service = FCMNotification(api_key=apikey)
self.STATUS_YES = 'Y'
self.STATUS_NO = 'N'
self.all_days = [
'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday',
'Sunday'
]
self.config = json.load(open(CONFIG_PATH))
self.client_id = self.get_config('basic', 'client_id')
def get_config(self, *args):
ret = self.config
for i in range(len(args)):
ret = ret[args[i]]
return ret
def build_url(self, addr, *args):
'''
:param addr: Address
:param args: list of components in the url. Will be appended with '/'
:return: returns the formatted url
'''
comp = ''
for i in range(len(args) - 1):
comp += args[i] + '/'
comp += args[len(args) - 1]
url = urllib.parse.urljoin("http://" + addr, comp)
logger.debug('Built url : ', url)
return url
def get_request(self, url, data=None):
'''
:param url: url to send the get request
:param params: params to append to the query
:return: response from the server
'''
response = None
try:
self.logger.debug('GET request : %s', url)
params = json.dumps(data)
self.logger.debug(str(params))
response = requests.get(url, params=params)
except Exception as e:
print(e)
return response
def query_installs(self, request, cur_session):
'''
queries Install table according to all ids supplied
in request object
:param request: current request context
:param cur_session: current database session object
:returns: List of matching entries if present, None otherwise
'''
u_id = self.read_user_id(request.args.get('u_id', None))
i_id = request.args.get('i_id', None)
p_id = request.args.get('p_id', None)
return self.get_all_installs(cur_session, u_id, i_id, p_id)
def get_all_installs(self, cur_session, u_id=None, i_id=None, p_id=None):
if i_id is None and p_id is None and u_id is None:
return None
if i_id is not None:
cur_installs = cur_session.query(Install).filter(
Install.install_id == i_id).all()
elif u_id is not None:
cur_installs = cur_session.query(Install).filter(
Install.user_id == u_id).all()
else:
cur_installs = cur_session.query(Install).filter(
Install.push_id == p_id).all()
if len(cur_installs) == 0:
return None
return cur_installs
def get_all_medications(self,
cur_session,
m_id=None,
m_name=None,
u_id=None,
d_id=None):
if m_id is None and u_id is None and d_id is None and m_name is None:
return None
if m_id is not None:
cur_meds = cur_session.query(Medication).filter(
Medication.med_id == m_id).all()
elif u_id is not None:
cur_meds = cur_session.query(Medication).filter(
Medication.user_id == u_id).all()
elif m_name is not None:
cur_meds = cur_session.query(Medication).filter(
Medication.med_name == m_name).all()
else:
cur_meds = cur_session.query(Medication).filter(
Medication.dosage_id == d_id).all()
if len(cur_meds) == 0:
return None
return cur_meds
def keygen(self, cur_session, cur_table, table_attr):
key = np.random.randint(0, 2**31)
prev_entry = cur_session.query(cur_table).filter(
table_attr == key).first()
if prev_entry is not None:
return self.keygen(cur_session, cur_table, table_attr)
return key
def stringify(self, lst):
ret = ''
for s in lst:
if len(s) == 0:
continue
ret += ',' + s
return ret[1:]
def send_push_notification(self, reg_id_list, data_message=None):
'''
: param reg_id_list: list of registration ids
: param data_message: optional payload with custom key-value pairs
: returns: Sends out push notification to multiple devices.response data from pyFCM
'''
if len(reg_id_list) == 0:
self.logger.debug(
'No registration ids to send push notification to')
return
if len(reg_id_list) == 1:
self.logger.debug('Making call to FCM for single Data Message...')
try:
result = self.push_service.single_device_data_message(
registration_id=reg_id_list[0], data_message=data_message)
except Exception as e:
self.logger.debug(e)
return None
else:
self.logger.debug(
'Making call to FCM for multiple Data Messages...')
try:
result = self.push_service.multiple_devices_data_message(
registration_ids=reg_id_list, data_message=data_message)
except Exception as e:
self.logger.debug(e)
return None
return result
# Is there a better way to do this?
def get_clean_data_array(self, shape):
# ret = np.empty(shape, dtype=object)
# This has problems : https://stackoverflow.com/questions/33983053/how-to-create-a-numpy-array-of-lists
# ret.fill([])
'''
IMPORTANT! The first element (index 0) will be None. Use lists starting from 1
'''
linear_size = 1
for s in shape:
linear_size *= s
ret = np.empty((linear_size, ), dtype=object)
for i, v in enumerate(ret):
ret[i] = list([])
# finally, reshape the matrix
ret = ret.reshape(shape)
return ret
def read_user_id(self, u_id):
if u_id is None or u_id == '':
return ''
algorithm = sha2()
algorithm.update(u_id.encode())
return algorithm.hexdigest().upper()
def validate_intakes(self, med, dose, cur_session):
# Oh boy...
validation_date = parser.parse(med.validation_date)
start_date = validation_date + timedelta(days=1)
med.validation_date = (datetime.now() - timedelta(days=1)).isoformat()
intakes = cur_session.query(Intake).filter(
Intake.med_id == med.med_id).filter(
Intake.planned_date > validation_date).all()
ideal_intake_dates = self.get_ideal_intake_dates(dose, start_date)
intake_dates_present = set(
[parser.parse(x.planned_date) for x in intakes])
missed_intake_dates = [
x for x in ideal_intake_dates if x not in intake_dates_present
]
missed_intakes = [
Intake(med_id=med.med_id,
planned_date=x.isoformat(),
intake_status=3) for x in missed_intake_dates
]
cur_session.add_all(missed_intakes)
cur_session.commit()
def get_ideal_intake_dates(self, dose, start_date):
ideal_intakes = []
def get_prev_dosage_date(days, cur_date):
cur_day_idx = cur_date.weekday()
prev_day_idx = -1
for i in range(len(days) - 1, -1, -1):
if days[i] < cur_day_idx:
prev_day_idx = i
break
prev_day_delta = (cur_day_idx - days[prev_day_idx] + 7) % 7
td = timedelta(days=prev_day_delta)
return cur_date - td
dosage_days = [self.all_days.index(x) for x in dose.get_days()]
ideal_times = [
get_prev_dosage_date(dosage_days, parser.parse(tim))
for tim in dose.get_times()
]
ideal_times.reverse()
while ideal_times[0].date() >= start_date.date():
ideal_intakes.extend(ideal_times)
ideal_times = [
get_prev_dosage_date(dosage_days, tim) for tim in ideal_times
]
return reversed(ideal_intakes)
def get_intake_status(self, planned_date, actual_date):
p_date = parser.parse(planned_date)
a_date = parser.parse(actual_date)
delta = time.mktime(a_date.utctimetuple()) - time.mktime(
p_date.utctimetuple())
four_hours = 1000 * 60 * 60 * 4
if delta < 0:
return 1
elif delta > four_hours:
return 2
return 0
def fcm_send_bulk_data_messages(
api_key,
registration_ids=None,
condition=None,
collapse_key=None,
delay_while_idle=False,
time_to_live=None,
restricted_package_name=None,
low_priority=False,
dry_run=False,
data_message=None,
content_available=None,
timeout=5,
json_encoder=None):
"""
Arguments correspond to those from pyfcm/fcm.py.
Sends push message to multiple devices,
can send to over 1000 devices
Args:
api_key
registration_ids (list): FCM device registration IDs.
data_message (dict): Data message payload to send alone or with the notification message
Keyword Args:
collapse_key (str, optional): Identifier for a group of messages
that can be collapsed so that only the last message gets sent
when delivery can be resumed. Defaults to ``None``.
delay_while_idle (bool, optional): If ``True`` indicates that the
message should not be sent until the device becomes active.
time_to_live (int, optional): How long (in seconds) the message
should be kept in FCM storage if the device is offline. The
maximum time to live supported is 4 weeks. Defaults to ``None``
which uses the FCM default of 4 weeks.
low_priority (boolean, optional): Whether to send notification with
the low priority flag. Defaults to ``False``.
restricted_package_name (str, optional): Package name of the
application where the registration IDs must match in order to
receive the message. Defaults to ``None``.
dry_run (bool, optional): If ``True`` no message will be sent but
request will be tested.
Returns:
:tuple:`multicast_id(long), success(int), failure(int), canonical_ids(int), results(list)`:
Response from FCM server.
Raises:
AuthenticationError: If :attr:`api_key` is not set or provided or there is an error authenticating the sender.
FCMServerError: Internal server error or timeout error on Firebase cloud messaging server
InvalidDataError: Invalid data provided
InternalPackageError: JSON parsing error, mostly from changes in the response of FCM, create a new github issue to resolve it.
"""
push_service = FCMNotification(
api_key=SETTINGS.get("FCM_SERVER_KEY") if api_key is None else api_key,
json_encoder=json_encoder,
)
return push_service.multiple_devices_data_message(
registration_ids=registration_ids,
condition=condition,
collapse_key=collapse_key,
delay_while_idle=delay_while_idle,
time_to_live=time_to_live,
restricted_package_name=restricted_package_name,
low_priority=low_priority,
dry_run=dry_run,
data_message=data_message,
content_available=content_available,
timeout=timeout
)
def multiple_devices_data_message(registration_ids: RegistrationIds,
data_message: dict, **kwargs):
push_service = FCMNotification(api_key=settings.FCM_API_KEY)
return push_service.multiple_devices_data_message(
registration_ids=registration_ids, data_message=data_message, **kwargs)
