예제 #1
25
def enviar_notificacao(sender, instance, **kwargs):
    # Instância da classe FCMNotification com parâmetro da API
    push_service = FCMNotification(api_key="AIzaSyDXv8_47S0_g64d5sHvwZWpH98gyJDUhtc")
    # Método que passa os parâmetros de configuração do alerta do push
    # Recebe o que vem da categoria e passa para a função de envio, obs: Tiramos o uso do IF
    push_service.notify_topic_subscribers(topic_name='%s' % instance.categoria.desc,
                                            sound=True,
                                            color=None,
                                            message_body=instance.titulo,
                                            #condition=topic_condition
                                            )
예제 #2
0
파일: fcm.py 프로젝트: darwinv/api-chat-lnk
 def fcm_send_data(user_id, data=None):
     """Funcion para enviar mensaje a traves de topicos en Firebase."""
     # Notificaciones push para dispositivos moviles
     # manejamos 2 funciones para cada plataforma  en  especifico.
     api_key = FcmConfig.FCM_SETTINGS.get("FCM_SERVER_KEY")
     # topico para android
     topic = "user-" + str(user_id)
     # topico para IOS
     topic_ios = "ios-user-" + str(user_id)
     title_ios = data["title"]
     body_ios = data["body"]
     # configuracion de apikey
     push = FCMNotification(api_key=api_key)
     # funcion para enviar a android, con data_message
     result = push.notify_topic_subscribers(topic_name=topic,
                                            data_message=data)
     # funcion para enviar a IOS, con  notification message
     result_ios = push.notify_topic_subscribers(topic_name=topic_ios,
                                                message_title=title_ios,
                                                message_body=body_ios,
                                                data_message=data,
                                                badge=data["badge"])
     # do not raise errors, pyfcm will raise exceptions if response
     # status will # be anything but 200
     # import pdb; pdb.set_trace()
     # print(user_id)
     # print(data)
     # print(body_ios)
     # print(result)
     # print(result_ios)
     return result
예제 #3
0
    def post(app_name):
        push_service = FCMNotification(api_key=PUSHCONF['API_KEY'])

        parser = reqparse.RequestParser()
        parser.add_argument('topic',
                            type=str,
                            location='json',
                            required=True,
                            help='queue topic cannot be blank')
        parser.add_argument('message',
                            type=str,
                            location='json',
                            required=True,
                            help='message cannot be blank')
        parser.add_argument('access_token',
                            type=str,
                            location='json',
                            required=True)
        args = parser.parse_args(strict=True)

        push_service.notify_topic_subscribers(topic_name='event_' +
                                              args['topic'],
                                              message_body=args['message'])

        return {'ack': 'true'}, 200
예제 #4
0
def push_notif(id, message_title, message_body):
    api_keys = 'AAAAaxCakgY:APA91bG4JlqQn6YhGAoPck1_moeHW4PxUWiPxnjEmxqfbVLTCVk7Wfn6fOq7AR7b_zPBF0oR9ln-d1maLH5ZoqbFea0eEl0O10RHUYyljyztqkwJEq46kZwVgKgt377PwVH00pjR87i4'

    push_service = FCMNotification(api_key=api_keys)
    push_service.notify_topic_subscribers(topic_name=str(id),
                                          message_title=message_title,
                                          message_body=message_body)
예제 #5
0
    def notify(title, message):
        key = "KEY"

        push_service = FCMNotification(api_key=key)
        if len(message) > 51:
            message = message[:50] + '...'
        push_service.notify_topic_subscribers(topic_name="news",
                                              message_body=message,
                                              message_title=title)
예제 #6
0
def send_notification_noticias(sender, instance, created, **kwargs):
    push_service = FCMNotification(api_key=api_key)
    if created:
        message = str(instance.title)
        title = "Nueva noticia"
    else:
        message = str(instance.title)
        title = "Actualización de noticia"
    data_message = {
        "type": "noticia",
        "noticia": str(instance.pk)
    }
    push_service.notify_topic_subscribers(message_title=title,topic_name="news",data_message=data_message, message_body=message,time_to_live=0)    
예제 #7
0
def send_notification_premio(sender, instance, created, **kwargs):
    push_service = FCMNotification(api_key=api_key)
    premio = instance.name
    if created:
        message = str(premio)
        title = "Resultados"
    else:
        message = str(premio)
        title = "Actualización de Resultados"
    data_message = {
        "type": "premio",
        "premio": str(instance.pk)
    }
    push_service.notify_topic_subscribers(message_title=title,topic_name="results", message_body=message,data_message=data_message,time_to_live=0)
예제 #8
0
def send_push(request):

    if request.method == 'POST':

        received_data = request.body
        received_push_dict = ast.literal_eval(received_data)
        push_topic = received_push_dict['topic']
        push_msg = received_push_dict['message']
        push_num = received_push_dict['number']

        try:

            push_service = FCMNotification(api_key='AAAAtoaWwyQ:APA91bFTmtGT2-ku-nnwUgiNgD51IhphQEdemKsAnmfcwVgzwU3OAyxy6UJ8IX7OCZcxWCShPM03_F-IYdfDy6rHs1vbjT04kbngXf7KvGMKUE-cdAFNv4PLEjw2NZMiDE1UU9rxmwcU')

            message_title = "KUB Story"
            message_body = push_msg

            result = push_service.notify_topic_subscribers(topic_name=str(push_topic), message_body=message_body, message_title=message_title)

            sent_push = Push(push_author=push_topic, push_title=push_msg, push_number=push_num)
            sent_push.save()

            return HttpResponse(json.dumps({'response':'success'}))

        except Exception as e:
            print(str(e))
            return HttpResponse(json.dumps({'response':'fail'}))

    else:
        return HttpResponse('Request is not in POST form')
예제 #9
0
class FCM:
    """
    Firebase Cloud Messaging Client Module.
    Leverages pyfcm library for API requests
    """
    def __init__(self):
        self.push_service = None

    def init_push_service(self, api_key):
        self.push_service = FCMNotification(api_key=api_key)

    def send_notification(self, topic, message, data, click_action):
        self.push_service.notify_topic_subscribers(topic_name=topic,
                                                   message_body=message,
                                                   data_message=data,
                                                   click_action=click_action)
예제 #10
0
파일: fcm.py 프로젝트: ysinjab/fcm-django
def fcm_send_topic_message(api_key=None,
                           json_encoder=None,
                           topic_name=None,
                           message_body=None,
                           message_title=None,
                           message_icon=None,
                           sound=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,
                           click_action=None,
                           badge=None,
                           color=None,
                           tag=None,
                           body_loc_key=None,
                           body_loc_args=None,
                           title_loc_key=None,
                           title_loc_args=None,
                           content_available=None,
                           timeout=5,
                           extra_notification_kwargs=None,
                           extra_kwargs={}):

    if api_key is None:
        api_key = SETTINGS.get("FCM_SERVER_KEY")
    push_service = FCMNotification(api_key=api_key, json_encoder=json_encoder)
    result = push_service.notify_topic_subscribers(
        topic_name=topic_name,
        message_body=message_body,
        message_title=message_title,
        message_icon=message_icon,
        sound=sound,
        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,
        click_action=click_action,
        badge=badge,
        color=color,
        tag=tag,
        body_loc_key=body_loc_key,
        body_loc_args=body_loc_args,
        title_loc_key=title_loc_key,
        title_loc_args=title_loc_args,
        content_available=content_available,
        timeout=timeout,
        extra_kwargs=extra_kwargs,
        extra_notification_kwargs=extra_notification_kwargs,
    )

    return result
예제 #11
0
class MonitorMessageSender:
    def __init__(self):
        '''
        Constructor
        '''
        self.__push_service = FCMNotification(api_key=API_KEY)

    def send_account_balance(self, btc, usd, currencies=[], market="Bittrex"):
        coins = []
        for coin in currencies:
            if not isinstance(coin, Currency):
                raise Exception(
                    'illegal variable currencies, use array of Currency')
            coins.append(coin.to_json())
        message_data = {
            'btc': btc,
            'usd': usd,
            "update_time": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
            'currencies': coins,
            "market": market
        }
        print(message_data)
        result = self.__push_service.notify_topic_subscribers(
            topic_name=TOPIC_NEWS,
            message_title=TITLE_ACCOUNT_BALANCE,
            tag=TYPE_ACCOUNT_BALANCE,
            data_message=message_data)
        print(result)
예제 #12
0
def send_device_android_notification_worker(user_uuid, device_uuid,
                                            user_sensor_name, device_name,
                                            user_sensor_uuid, status,
                                            time_reached):
    # header = {
    #     "Content-Type": "application/x-www-form-urlencoded"
    # }
    #
    # payload = {
    #     'user_uuid' : 'user_uuid'
    #     'device_uuid': device_uuid,
    #     'device_name': device_name,
    #     'user_sensor_uuid': user_sensor_name,
    #     'user_sensor_name'   : user_sensor_uuid,
    #     'status': status,
    #     'timestamp': timestamp
    # }
    # response = requests.post(url=SEND_ANDROID_NOTIFICATION_ENDPOINT,data=payload, headers=header)

    push_service = FCMNotification(api_key=FCM_API_KEY)

    payload = {
        "data": {
            "user_uuid": user_uuid,
            "device_uuid": device_uuid,
            "device_name": device_name,
            "user_sensor_uuid": user_sensor_uuid,
            "user_sensor_name": user_sensor_name,
            "status": status,
            "timestamp": float(datetime.now().timestamp())
        }
    }

    result = push_service.notify_topic_subscribers(topic_name=user_uuid,
                                                   data_message=payload)
예제 #13
0
class FCMSender:
    def __init__(self, server_key):
        self.push_service = FCMNotification(api_key=server_key)

    def send(self, title, message, registration_id=None):
        message_title = title
        message_body = message

        if registration_id is None:
            result = self.push_service.notify_topic_subscribers(topic_name='all',
                                                                message_title=message_title,
                                                                message_body=message_body)
        else:
            result = self.push_service.notify_single_device(registration_id=registration_id,
                                                            message_body=message_body,
                                                            message_title=message_title)

        print(result)
        return result

    @staticmethod
    def get_clients_to_push():
        rows = database.Database().execute(query_formats.get_registration_id_format)
        clients_to_push = list()
        for row in rows:
            clients_to_push.append(row['registration_key'])

        return clients_to_push
예제 #14
0
파일: fcm.py 프로젝트: xtrinch/fcm-django
def fcm_send_topic_message(
        api_key=None,
        json_encoder=None,
        topic_name=None,
        message_body=None,
        message_title=None,
        message_icon=None,
        sound=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,
        click_action=None,
        badge=None,
        color=None,
        tag=None,
        body_loc_key=None,
        body_loc_args=None,
        title_loc_key=None,
        title_loc_args=None,
        content_available=None,
        timeout=5,
        extra_kwargs={}):

    if api_key is None:
        api_key = SETTINGS.get("FCM_SERVER_KEY")
    push_service = FCMNotification(api_key=api_key, json_encoder=json_encoder)
    result = push_service.notify_topic_subscribers(
        topic_name=topic_name,
        message_body=message_body,
        message_title=message_title,
        message_icon=message_icon,
        sound=sound,
        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,
        click_action=click_action,
        badge=badge,
        color=color,
        tag=tag,
        body_loc_key=body_loc_key,
        body_loc_args=body_loc_args,
        title_loc_key=title_loc_key,
        title_loc_args=title_loc_args,
        content_available=content_available,
        timeout=timeout,
        extra_kwargs=extra_kwargs
    )

    return result
예제 #15
0
 def send_topic(self, jsondata, topic):
     try:
         push_service = FCMNotification(api_key=FCM.FCM_API_KEY)
         result = push_service.notify_topic_subscribers(
             data_message=jsondata, topic_name=topic)
         print(result)
     except Exception as e:
         print("fcm_topic error: {}".format(e))
예제 #16
0
class Firebase:
    def __init__(self, app):
        self.app = app
        api_key = self._get_api_key()
        if api_key is not None:
            self.push_service = FCMNotification(api_key=api_key)
        self.last_send_time = None
        self.notifications = True

    def toggle_notifications_based_on_distance(self, lon, lat):
        distance_meters = calculate_distance(lon, lat,
                                             *self._get_pi_location())

        if distance_meters is None:
            return -1

        self.notifications = (distance_meters > MIN_DISTANCE_FOR_NOTIFICATIONS)
        print("Notifications turned {}!".format(
            "on" if self.notifications else "off"))
        return distance_meters

    def send_movement_push_notification(self):
        delta = time.time() - (self.last_send_time or 0)
        if delta > PUSH_NOTIFICATION_INTERVAL:
            self.last_send_time = time.time()
            self._send_push_notification(
                "movement", "Detected movement in front of your house!",
                "Movement detected!")

    def _send_push_notification(self, topic, message, title):
        if self.push_service is not None:
            self.push_service.notify_topic_subscribers(topic,
                                                       message_body=message,
                                                       message_title=title)
        else:
            print("Skipped sending push notification, API key not provided!")

    def _get_api_key(self):
        return self.app.config["FIREBASE_API_KEY"]

    def _get_pi_location(self):
        lon = self.app.config["PI_LONGITUDE"]
        lat = self.app.config["PI_LATITUDE"]
        return lon, lat
예제 #17
0
class FCM:
    """
    Firebase Cloud Messaging Client Module.
    Leverages pyfcm library for API requests
    """

    def __init__(self):
        self.push_service = None


    def init_push_service(self, api_key):
        self.push_service = FCMNotification(api_key=api_key)


    def send_notification(self, topic, message, data, click_action):
        self.push_service.notify_topic_subscribers(topic_name=topic,
                                                   message_body=message,
                                                   data_message=data,
                                                   click_action=click_action)
예제 #18
0
def send_message():
    msg = request.form['msg']
    #data_message = {"body":msg}
    push_service = FCMNotification(
        api_key=
        "AAAAPyvvG34:APA91bEZ0x963WnD7YJvsIIrEst-GndqnYP02nE2Utca5gK3a_XjpCVLe4dmHh_pwHjPbYhxK-kqZvzZhOMTvvOAtxvO2ZPyHnHxBp2uVCeEZvNI4DgdFUpe1Nl-wS_KGWvueOuHL8NI"
    )
    result = push_service.notify_topic_subscribers(topic_name="all",
                                                   data_message={"body": msg})
    return msg
예제 #19
0
class NestFCMManager:
    ADMIN_TOPIC = "admin"
    NONADMIN_TOPIC = "non-admin"

    def __init__(self):
        with open(os.path.join(os.environ["MYH_HOME"], "data", "fcm.json")) as fcm_file:
            fcm_dict = json.load(fcm_file)
            api_key = fcm_dict["api_key"]
        self.push_service = FCMNotification(api_key=api_key)

    def sendMessage(self, message_title, message_body, topic_name):
        self.push_service.notify_topic_subscribers(topic_name=topic_name, message_body=message_body,
                                                            message_title=message_title)

    def sendMessageAdmin(self, message_title, message_body):
        self.sendMessage(message_title, message_body, self.ADMIN_TOPIC)

    def sendMessageNonAdmin(self, message_title, message_body):
        self.sendMessage(message_title, message_body, self.NONADMIN_TOPIC)
예제 #20
0
def sendAlert(message, type):
    from pyfcm import FCMNotification
    import os

    global lastHumidityTime
    global lastTemperatureTime

    push_service = FCMNotification(api_key=os.environ['FCM_KEY'])
    if type is "humidity" and lastHumidityTime + 300000 < int(
            round(time.time() * 1000)):
        print("Sending humidity Alert")
        lastHumidityTime = int(round(time.time() * 1000))
        push_service.notify_topic_subscribers(topic_name="alerts",
                                              message_body=message)
    if type is "temperature" and lastTemperatureTime + 300000 < int(
            round(time.time() * 1000)):
        print("Sending temperature Alert")
        lastTemperatureTime = int(round(time.time() * 1000))
        push_service.notify_topic_subscribers(topic_name="alerts",
                                              message_body=message)
예제 #21
0
def push_notification(request):
    if request.method == 'POST':
        topic = request.POST.get('topic')
        title = request.POST.get('title')
        message = request.POST.get('message')
        push_service = FCMNotification(api_key=settings.FCM_API_KEY)
        result = push_service.notify_topic_subscribers(
            topic_name=topic,
            message_title=title,
            message_body=message,
        )
        return redirect(request.META.get('HTTP_REFERER'))
예제 #22
0
class FCMSender:
    def __init__(self, server_key):
        self.push_service = FCMNotification(api_key=server_key)

    def send(self, topic_id, topic_name):
        message_title = topic_name
        message_body = '새로운 메시지가 있습니다'
        result = self.push_service.notify_topic_subscribers(
            topic_name=topic_id,
            message_title=message_title,
            message_body=message_body)

        return result
예제 #23
0
def send_push_notification_fcm(message):
	"""
	Using Firebase Cloud Messaging (FCM) to send notification to android device
	"""
	push_service = FCMNotification(api_key="AAAAisuS5ss:APA91bH5m303tDXY2eQlVAYygRIqH2oRAiiVDxaVnipG-McWJjVX3xWXXIOMauUV0dUhdPnqvrbI5tmZd2zHV9ixULm71m9uWtNNQjnoEIe0bTYgVzYlg32gkds07EJv_6WOC3vnzz-k")
	message_title = "Warning"
	message_body = "Too hot!"
	data_message = {
		"title" : "LoRa System WARNING!!!",
		"body" : message,
		}
	# result = push_service.notify_topic_subscribers(topic_name="LORA_SYSTEM", message_body=message_body, message_title=message_title)
	result = push_service.notify_topic_subscribers(topic_name="LORA_SYSTEM", data_message=data_message)
	print(result)
예제 #24
0
 def send(self, notifications, users):
     for notification in notifications:
         object_data = self.get_object(notification)
         push_service = FCMNotification(api_key=FIREBASE_API_KEY)
         response = push_service.notify_topic_subscribers(
             topic_name=self.get_topic(object_data),
             message_body=self.build_notification_body(notification),
             message_title=self.title,
             click_action='FLUTTER_NOTIFICATION_CLICK',
             data_message={
                 'type': self.object_field,
                 'id': object_data.pk
             })
     return True
예제 #25
0
def incidents(user_id):
    # SEARCH FOR USER, SEND NOTIFICATION AND SEND INFORMATION
    #AIzaSyBzu6jeeyGabLpGPj7KutBzR-BmXwsMcrc
    #Expected Input = {USER_ID, LOCATION{latitude, longitude}}
    id = request.view_args['user_id']

    crud.createIncident(request.json, id)
    push_service = FCMNotification(
        api_key="AIzaSyBzu6jeeyGabLpGPj7KutBzR-BmXwsMcrc")
    result = push_service.notify_topic_subscribers(topic_name="covadonga",
                                                   message_body='Alerta!')
    response = jsonify({'prueba': 'pruebita'})
    response.headers.add('Access-Control-Allow-Origin', '*')
    return response
예제 #26
0
def sendPush():

    data_message = {
        "title": "Deep Pi - Alert",
        "body": "System detected fire. Please check it out.",
    }

    push_service = FCMNotification(
        api_key=
        "AAAAZW9shM0:APA91bEBRY3WT8AzjM86hWVhUaOJP9O_zKhVX8PDlVD6MVHV_7ofMu6FBDgKBt7gHCJ2RjYIOoeYkoFRPWVtlYtAF5Uou7HUe6Ky6ZLJ_I2JK1zCVjqyz3Z120IuHuVVg6W48Ywuxc29"
    )
    print("[FCM MANAGER] Will send push")
    result = push_service.notify_topic_subscribers(topic_name="fire",
                                                   content_available=True,
                                                   data_message=data_message)
예제 #27
0
파일: fcm.py 프로젝트: jbc25/eticsAppServer
def topic_message(topic, data=None, title=None, body=None, silent=True):
    push_service = FCMNotification(api_key=settings.FCM_SERVER_KEY)

    if not data:
        data = {}
    if not body and not title:
        silent = True
    if title and silent:
        data['title'] = title
    if body and silent:
        data['message'] = body

    result = push_service.notify_topic_subscribers(topic_name=topic,
                                                   message_title=title,
                                                   message_body=body,
                                                   data_message=data)
    return result
def uploadNotification(video_id, video_title, course):
    key = "AAAAhHPOtR4:......"

    push_service = FCMNotification(api_key=key)

    data = {

        "type":"upload",
        "video_title":video_title,
        "video_url":video_id,
        "click_action":"FLUTTER_NOTIFICATION_CLICK",
        "route":"youtube"
    }
    # Changed message_icon to  ['notification']['image'] field in library files for my use case
    result = push_service.notify_topic_subscribers(topic_name=course, message_title="A new video has been uploaded", message_body="Please tap on this notification to continue", data_message=data, message_icon=f"https://img.youtube.com/vi/{data['video_url']}/hqdefault.jpg")

    if result['success'] == 1:
        print("notification sent") 
예제 #29
0
def sendNotification(temp):
    push_service = FCMNotification(
        api_key=
        "AAAAwcaNGIE:APA91bG8XH4WgdqS7akF0PYAuSPJ8G-9t-YmjaRNGxwKfRLPinSWf3ngFAseKVmn1Ge3kN9XogJOIGlA5EeRJneQb0_Q2-bXgIy3-UKp0OVG0dOOKcRD4CE3SXMvzHjpU5ajps3VRGtN"
    )
    message_title = "Room Temperature"
    if temp > 23:
        message_body = "The Room Temperature is more then 23c"
    else:
        message_body = "The Room Temperature is less then 16c"
    result = push_service.notify_topic_subscribers(
        topic_name="RoomTemperature",
        message_title=message_title,
        message_body=message_body,
        sound=True)
    #print "sending Notification"
    #print volume
    return
예제 #30
0
    def sendnotif(self):
        push_service = FCMNotification(
            api_key=
            'AAAAMLtwGK0:APA91bEqXYrlOa3f4Cgn-pEInxWzrEsVQr4pCnCCOMsXuyjqU1zpJyzIzyl1R6vY41Yd3qW71CBKahpk259jCxZlHi7Vidj_UDxOHQCp3l3VNBS65vwKs5nK3YbyHutl52p53_rn4kLe'
        )
        try:
            result = push_service.notify_topic_subscribers(
                topic_name='global',
                message_body=self.body,
                message_title=self.head,
                color=self.col)
            print("Sent to %d Locations Sucessfully, %d Failed.." %
                  (result['success'], result['failure']))
        except:
            print("Error while sending Notification!")


# no=Notify("Test Function","Testing through a class!!","blue")
# no.sendnotif()
예제 #31
0
def notify(api_key: str, message: str, topic: str, title: str, data: object = {}):
    """
    Notifies a topic
    :param api_key: Api key to send to
    :param message:  Message that should be notified (optional)
    :param topic: Topic that message should be sent to
    :param title: Title of the message
    :param data: Extra data to send (optional)
    """
    push_service = FCMNotification(api_key=api_key)

    if message is not None:
        data['message'] = message

    if title is not None:
        data['title'] = title

    result = push_service.notify_topic_subscribers(topic_name=topic, data_message=data)

    print(result)
예제 #32
0
class FirebaseUtils:
	
	def __init__(self, bucket, conf):
		self.bucket = bucket
		self.conf = conf
		self.push_service = FCMNotification(api_key=conf["api_key"])

	# Upload image on Firebase
	def upload(self, frame,ts, notification = True):
		# Save frame on disk
		cv2.imwrite("images/snapshot.jpg", frame)
		# Create blob
		blob = self.bucket.blob('{base_path}/{timestamp}.jpg'.format(base_path = self.conf['base_path'], timestamp=ts))
		# Upload image on firebase
		blob.upload_from_filename("images/snapshot.jpg", content_type="image/jpg")
		# Trigger notification if required
		if(notification):
			# Create notification
			message_title = "Intrusion detected"
			message_body = "ATTENTION! INTRUSION!"
			# Send notification to topic
			result = self.push_service.notify_topic_subscribers(topic_name=self.conf["base_path"], message_body=message_body, message_title = message_title)
예제 #33
0
def pushNotification():
    push_service = FCMNotification(
        api_key=
        "AAAAuQBCBPE:APA91bGKiYJ_hPLifHUJebsjMSjlLUvjkoLpYcTCPDTkgHy7hwlOR6rSa0w3CFrfG7qg8p-p9jerFNoQT5G5DKMMyBz8JvJ4rzK0xGv_VCdCyHKWnbY3B0PLCj4TQlP7t_7S9IwABEum"
    )

    jsonData = request.json

    cliente = jsonData['cliente']
    pedido = jsonData['pedido']
    cantidad = jsonData['cantidad']
    telefono = jsonData['telefono']
    colonia = jsonData['colonia']
    calle = jsonData['calle']
    numero = jsonData['numero']

    dataPayLoad = {
        "cliente": cliente,
        "pedido": pedido,
        "cantidad": cantidad,
        "telefono": telefono,
        "colonia": colonia,
        "calle": calle,
        "numero": numero,
    }

    message_title = "Pedido"
    message_body = "Nuevo pedido realizado"
    result = push_service.notify_topic_subscribers(
        topic_name="restaurant_topic",
        message_title=message_title,
        message_body=message_body,
        click_action='FLUTTER_NOTIFICATION_CLICK',
        data_message=dataPayLoad)

    return result
def send_notification_to_topic():
    body = request.get_json()
    if not body:
        raise MissingJSONBodyException(status_code=400)
    if 'topic' not in body or 'title' not in body or 'body' not in body:
        raise JSONBodyFormatException(status_code=400)

    topic_name = body.get('topic')
    message_title = body.get('title')
    message_body = body.get('body')

    push_service = FCMNotification(api_key=api_key)
    result = push_service.notify_topic_subscribers(topic_name=topic_name,
                                                   message_body=message_body,
                                                   message_title=message_title)
    print(result)
    success = bool(result['success'])
    if success:
        status_code = 200
    else:
        status_code = 500
    return jsonify({
        'success': success,
    }), status_code
예제 #35
0
class DsoftHttpRequest():
    """
    Initial the Http Request to backend server
    Set the username and password of caster user 
    Initial the Firebase Notification
    """
    def __init__(self):
        self.username = api.API_USER
        self.password = api.API_PWD
        self.token = ''
        self.push_fcm = FCMNotification(api_key=api.FCM_KEY)
    """
    Login to Backend Server with user info from api constant file.
    Save the token to memory variable
    """
    def login(self):
        jsonData = {"username": self.username, "password": self.password}
        r = requests.post(api.LOGIN_API, json=jsonData)
        if r.status_code == 200:
            self.token = r.json()['data']['access_token']
            print('Login successful with access-token: {}'.format(self.token))
        else:
            self.token = ''
            print('Login failed with error: {}'.format(str(r.status_code)))
    """
    Get token
    """    
    def __get_token(self):
        return self.token
    """
    Post work log when user is recognited
    @param: image_path = Image path is set into Backend Server /publish/evidence
    @param: username = Name of staff is recognited
    @param: status = Direction In or Out
    """
    def post_worklog(self, image_path, username, status):
        userId = self.get_user_id(username)
        
        if userId == None:
            print('Failed to get username')
            return
        data = {"image": image_path}
        url = api.POST_WORKLOG + '/{}/{}'.format(userId, status) 
        print(url)
        print(userId)
        r = requests.post(url, json=data, headers={'access-token': self.token})
        if r.status_code == 200:
            print("Post worklog successful!")
        else:
            print("Failed to post worklog!")
        return r.status_code
        #self.__post_method(url, files= data)
    # def post_worklog(self, image_path, username, status):
    #     userId = self.get_user_id(username)
        
    #     if userId == None:
    #         print('Failed to get username')
    #         return
    #     data = {"_id": userId, "username": username, "status": status, "image": image_path}
    #     url = api.POST_WORKLOG + '/{}/{}'.format(userId, status) 
        
    #     print(userId)
    #     r = requests.post(url, json=data, headers={'access-token': self.token})
    #     if r.status_code == 200:
    #         print("Post worklog successful!")
    #     else:
    #         print("Failed to post worklog!")
        #self.__post_method(url, files= data)
    """
    Get user info to return to client
    @param: user_name = Username of staff
    @return: userInformation
    """
    def get_user_info(self, user_name):
        userID = self.get_user_id(user_name)
        url = api.GET_USER_INFO.format(userID)
        data = self.__get_method(url)
        return data
    """
    Get user ID
    @param: username = Username of staff need to get UserID
    @return userID = String of userID
    """
    def get_user_id(self, username):
        username = username.lower()
        url = api.GET_USER_ID.format(username)
        return self.__get_method(url)
    """
    Generic GET method
    @param: url: Url of get method
    @return:
        200: Successful
        403: Error Not Found
    """
    def __get_method(self, url):
        if not self.token:
            print("Token empty, try to login again!")
            self.login()
        r = requests.get(url, headers={'access-token': self.token})
        if r.status_code == 200:
            return r.json()["data"]
        elif r.status_code == 403:
            print(r.json()["errors"])
            # Try to login again
            self.login()
            return
    def opendoor(self, url, myfiles):
        r = requests.post(url, json = myfiles)
        return r.text


    """
    Generic POST method
    @param: url = URL of post method
    @param: files = Files to upload if need
    """
    def __post_method(self, url, files = None):
        if not self.token:
            print("Token empty, try to login again!")
            self.login()
        r = requests.post(url, files= files, headers={'access-token': self.token})
        print(r.status_code)
    """
    Send the notification with firebase
    @param: image_src: Path of image evidence
    """
    def notify_stranger(self, image_src):
        self.push_fcm.notify_topic_subscribers(
            topic_name = 'unknown',
            message_title = 'Stranger detect!!!',
            message_body = image_src
        )
        return 200
예제 #36
0
class GFireBase:

    def __init__(self, channel):
        self.config = channel.config
        self.push_service = FCMNotification(api_key=settings.FCM_API_SERVER_KEY)

    def notify_single(self, message):
        # TODO: Add model for subscribe
        list_username = list(message.user.all().values_list("username", flat=True))
        subscriptions = Subscribe.objects.filter(
            user__username__in=list_username,
            channel_id=message.channel.id,
            active=True).values_list('contact', flat=True)

        list_contact = []
        for contacts in subscriptions:
            for contact in contacts:
                list_contact.append(contact)
        subscriptions = list(list_contact)
        valid_registration_ids = self.push_service.clean_registration_ids(subscriptions)
        image = message.data.get('image')
        click_url = message.data.get('url')

        result = self.push_service.notify_multiple_devices(registration_ids=valid_registration_ids,
                                                           message_title=message.title,
                                                           message_body=message.body,
                                                           extra_notification_kwargs={"image": image},
                                                           data_message=message.data,
                                                           click_action="FLUTTER_NOTIFICATION_CLICK",
                                                           content_available=True,
                                                           extra_kwargs={"mutable_content": True}
                                                           )
        return result

    def notify_broadcast(self, message):
        image = message.data.get('image')
        click_url = message.data.get('url')
        topic = message.data.get("topic")
        user_type = message.data.get("user_type") if message.data.get("user_type") else "unknown_user"
        channel = message.channel
        topic_channel = f"{channel.type}_{user_type}"
        result = self.push_service.notify_topic_subscribers(topic_name=topic_channel,
                                                            message_title=message.title,
                                                            message_body=message.body,
                                                            extra_notification_kwargs={"image": image},
                                                            data_message=message.data,
                                                            click_action="FLUTTER_NOTIFICATION_CLICK",
                                                            content_available=True,
                                                            extra_kwargs={"mutable_content": True})
        return result

    def subscribe_topic(self, channel, registration_ids):
        topic_channel = f"{channel.type}"
        registration_ids = list(registration_ids)
        result = self.push_service.subscribe_registration_ids_to_topic(registration_ids, topic_channel)
        return result

    def unsubscribe_topic(self, channel, registration_ids):
        topic_channel = f"{channel.type}"
        registration_ids = list(registration_ids)
        result = self.push_service.unsubscribe_registration_ids_from_topic(registration_ids, topic_channel)
        return result

    def validate_registration_id(self, token_id):
        subscriptions = list(token_id)
        print(subscriptions)
        valid_registration_ids = self.push_service.clean_registration_ids(subscriptions)
        print(valid_registration_ids)
        if len(valid_registration_ids) > 0:
            return True, valid_registration_ids
        return False, []
예제 #37
0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
__author__ = 'olucurious'
from pyfcm import FCMNotification

push_service = FCMNotification(api_key="<api-key>")
registration_id="<device registration_id>"
message = "Hope you're having fun this weekend, don't forget to check today's news"
result = push_service.notify_topic_subscribers(topic_name="global", message_body=message)
print result
예제 #38
0
def enviar_notificacao(sender, **kwargs):
    push_service = FCMNotification(api_key="AIzaSyDXv8_47S0_g64d5sHvwZWpH98gyJDUhtc")
    push_service.notify_topic_subscribers(topic_name="bread", message_body=kwargs['conteudo'])