J'ai essayé APN (notification à distance) à l'aide de l'API REST Parse.com

Parse.com prend en charge la notification push. Je peux envoyer une notification push depuis Dashboard avec une interface utilisateur facile à comprendre, Vous pouvez également utiliser l'API REST pour envoyer des notifications push du côté de l'application. Il était un peu difficile de comprendre comment contrôler finement à l'aide de DeviceToken, donc je vais écrire à ce sujet.

Envoyer à l'API Parse

La notification push nécessite au moins ʻalert, donc si vous utilisez curl`, spécifiez ce qui suit et envoyez. Le «X-Parse-Application-Id» (ID de l'application) et la «X-Parse-REST-API-Key» (REST API Key) peuvent être obtenus à partir de l'aperçu du tableau de bord. Après cela, si vous êtes connecté et que vous regardez le document, vous pouvez l'exécuter tel quel car la clé est directement intégrée dans l'exemple de code !!

curl -X POST \
  -H "X-Parse-Application-Id: <Application ID>" \
  -H "X-Parse-REST-API-Key: <REST API Key>" \
  -H "Content-Type: application/json" \
  -d '{
        "data": {
          "alert": "The Giants won against the Mets 2-3."
        }
      }' \
  https://api.parse.com/1/push

À propos du format de notification d'analyse

Simplement exprimé, il est au format JSON suivant. Comme la condition est spécifiée dans where, vous pouvez envoyer une notification push à un terminal spécifique en spécifiant deviceToken ici.

--Mettez les données de notification iOS ou Android à la place de data --Facile à spécifier la date et l'heure de transmission et la date d'expiration

parse_push.py


{'where': {'deviceToken': [],                   #Spécification de condition à l'aide de l'API de requête
    },
    'push_time': '2013-01-23T12:00:00Z',        #Date et heure de début de la notification(iso)
    'expiration_interval': '518400',            #date d'expiration
    'expiration_time': '2013-01-23T21:08:39Z',  #Date et heure d'expiration spécifiées(iso)
    'data': {
        'alert': 'message',
        'badge': 'Increment',                   # Number or 'Increment'(iOS only).
        'sound': 'sound bundle',                # iOS only.
        'content-available': '1',               # Newsstand content count(iOS only).
        'action': 'Intent',                     # Android only.
        'title': 'Notification!!',              # Android only.
    }
}

Si vous spécifiez un opérateur conditionnel, il ressemble à ceci.

parse_push2.py


{'data': {'alert': 'push notification message!',
          'badge': 'Increment',
          'sound': 'default'},
 'where': {'deviceToken': {'$in': [u'<deviceToken1>', u'<deviceToken2>']}}}

Exemple de code

Écrit en Python, ça ressemble à ça.

apn.py


# coding: utf-8

PARSE_API_BASE = 'https://api.parse.com'
PARSE_PUSH_API = '/1/push'
PARSE_PUSH_URL = PARSE_API_BASE + PARSE_PUSH_API
#Spécifiez la clé requise pour la notification push avec en-tête HTTP
HEADERS = {
    "X-Parse-Application-Id": "<Application ID>",
    "X-Parse-REST-API-Key": "<REST API Key>",
    "X-Parse-Master-Key": "<Master Key>",
    "Content-Type": "application/json"
}


class APNMessageQueue(object):
    """ APN(Apple Push notification)Enregistrer les messages pour
    """
    structure = {
        'user_id': lambda x: (x is not None and len(x) > 0),
        'notify_token': lambda x: (x is not None and len(x) > 0),
        'message': lambda x: (x is not None and len(x) > 0),
    }

    def __init__(self, *args, **kwargs):
        for k in self.structure.keys():
            self.__setattr__(k, kwargs.get(k, None))

    @classmethod
    def create(cls, user_id, notify_token, message):
        src_props = dict(
            user_id=user_id,
            notify_token=notify_token,
            message=message,
        )
        props = {}

        for k, func in cls.structure.iteritems():
            value = src_props.get(k)
            if func(value):
                props[k] = value

        if props:
            return APNMessageQueue(**props)
        return None


def create_notify_message(message, badge='Increment', sound='default'):
    """Créer un format de notification push à partir du message de notification

    Args:
        message:Message d'alerte.
        badge:Nombre de lots('Increment'Est analyser.com original).
        sound:Son de notification.

    Return:
Chaîne de format PushNotification.

    """
    return {'alert': message, 'badge': badge, 'sound': sound}


def create_request_data(notify_token, apn_data):
    """Format de notification d'analyse Création de données de format de modèle

    Args:
        notify_token:Jeton d'appareil ou liste de celui-ci.
        apn_data:Données de notification Apple Push.

    Returns:
Analyser les données de format de modèle de format de notification.

    """
    request_data = {'data': apn_data}
    if isinstance(notify_token, list):
        request_data['where'] = {'deviceToken': {'$in': notify_token}}
    else:
        request_data['where'] = {'deviceToken': notify_token}
    return request_data


def process_do_send(request_data):
    """ParseNotification format Envoyer une notification Push en transmettant des données de format de modèle

    Args:
        request_data:Analyser les données de format de modèle de format de notification

    Returns:
Renvoie une interruption ou une erreur normale

    """
    import json
    from urllib2 import Request, urlopen, URLError

    payload = json.dumps(request_data)
    request = Request(PARSE_PUSH_URL, payload, HEADERS)
    try:
        response = urlopen(request)
        data = json.loads(response.read())
        if isinstance(data, dict):
            return data.get('result', False)
    except URLError, e:
        if hasattr(e, 'reason'):
            print 'We failed to reach a server.'
            print 'Reason: %s' % e.reason
        elif hasattr(e, 'code'):
            print 'The server couldn\'t fulfill the request.'
            print 'Error code: %d' % e.code
    return False


def send_notification(notify_queue_list):
    """Envoyer une notification push aux APN

Diffuser un message de notification push au serveur APNs

    Args:
        notify_queue_list:Liste APNMessageQueue

    """
    from itertools import groupby
    notify_sorted_queue_list = sorted(notify_queue_list, key=lambda x: x.message)
    #Envoyez le même message ensemble
    for message, group in groupby(notify_sorted_queue_list, key=lambda x: x.message):
        distict_tokens = list(set([user.notify_token for user in group]))
        aps_data = create_notify_message(message)
        request_data = create_request_data(distict_tokens, aps_data)
        print request_data
        process_do_send(request_data)

Le côté utilisateur est comme ça

main.py


# coding: utf-8

def send_push_parse_for_apn(message):
    import models
    import apn

    #Obtenir une liste de deviceTokens pour notification à partir des données utilisateur
    targets = [x for x in models.User.find_by_existing_notify_token() if x is not None]
    notify_token_list = [apn.APNMessageQueue(x.user_id, x.notify_token, message) for x in targets]

    if len(notify_token_list) > 0:
        #lancement
        apn.send_notification(notify_token_list)

if __name__ == '__main__':
    send_push_parse_for_apn('Abo!!')

Recommended Posts

J'ai essayé APN (notification à distance) à l'aide de l'API REST Parse.com
J'ai essayé d'utiliser l'API à distance avec GAE / J
J'ai essayé d'utiliser l'API checkio
J'ai essayé d'utiliser l'API de données YOUTUBE V3
J'ai essayé d'utiliser l'API UnityCloudBuild de Python
J'ai essayé d'utiliser l'API BigQuery Storage
J'ai essayé d'utiliser l'API Detect Labels d'AWS Rekognition
J'ai essayé d'utiliser l'API Google Cloud Vision
J'ai essayé d'utiliser paramétré
J'ai essayé d'utiliser argparse
J'ai essayé d'utiliser la mimesis
J'ai essayé d'utiliser anytree
J'ai essayé d'utiliser Summpy
J'ai essayé d'utiliser coturn
J'ai essayé d'utiliser Pipenv
J'ai essayé d'utiliser matplotlib
J'ai essayé d'utiliser "Anvil".
J'ai essayé d'utiliser Hubot
J'ai essayé d'utiliser ESPCN
J'ai essayé d'utiliser openpyxl
J'ai essayé d'utiliser Ipython
J'ai essayé d'utiliser PyCaret
J'ai essayé d'utiliser cron
J'ai essayé d'utiliser ngrok
J'ai essayé d'utiliser face_recognition
J'ai essayé d'utiliser Jupyter
J'ai essayé d'utiliser doctest
J'ai essayé d'utiliser du folium
J'ai essayé d'utiliser jinja2
J'ai essayé d'utiliser du folium
J'ai essayé d'utiliser la fenêtre de temps
J'ai essayé d'utiliser l'API de Sakenowa Data Project
[J'ai essayé d'utiliser Pythonista 3] Introduction
J'ai essayé d'utiliser easydict (mémo).
J'ai essayé la reconnaissance faciale avec Face ++
J'ai essayé d'utiliser RandomForest
J'ai essayé d'utiliser BigQuery ML
J'ai essayé d'utiliser git inspector
J'ai essayé d'utiliser magenta / TensorFlow
J'ai essayé d'utiliser AWS Chalice
J'ai essayé d'utiliser l'émojinateur Slack
J'ai essayé de rechercher des vidéos à l'aide de l'API de données Youtube (débutant)
J'ai essayé d'utiliser l'API de reconnaissance faciale des services cognitifs de Microsoft
[Python] J'ai essayé de collecter des données en utilisant l'API de wikipedia
[Pour les débutants] J'ai essayé d'utiliser l'API Tensorflow Object Detection
J'ai essayé d'utiliser Rotrics Dex Arm # 2
Obtenir des données Salesforce à l'aide de l'API REST
J'ai essayé de créer l'API Quip
J'ai essayé le roman Naro API 2
J'ai essayé d'utiliser Rotrics Dex Arm
J'ai essayé d'utiliser GrabCut d'OpenCV
J'ai essayé de marquer un concours de travesti en utilisant l'API Detect de Face ++
J'ai essayé d'utiliser l'API COTOHA (il y a aussi du code sur GitHub)
J'ai essayé d'analyser mon chanteur préféré (SHISHAMO) en utilisant l'API Spotify
J'ai essayé d'utiliser Thonny (Python / IDE)
J'ai touché l'API de Tesla
J'ai essayé de communiquer avec le client serveur en utilisant tmux
J'ai essayé l'API du roman Naruro