Partilhar via

Como utilizar os Hubs de Notificação do Python

  • Artigo

Pode aceder a todas as funcionalidades dos Notification Hubs a partir de um back-end Java/PHP/Python/Ruby com a interface REST do Hub de Notificação, conforme descrito no artigo APIs REST dos Hubs de Notificação do MSDN.

Nota

Esta é uma implementação de referência de exemplo para implementar a notificação enviada no Python e não é o SDK Python do Hub de Notificações oficialmente suportado. O exemplo foi criado com o Python 3.4.

Este artigo mostra-lhe como:

  • Crie um cliente REST para funcionalidades dos Hubs de Notificação em Python.
  • Enviar notificações através da interface Python para as APIs REST do Hub de Notificação.
  • Obtenha uma informação de falha de sistema do pedido/resposta REST de HTTP para fins educativos/depuração.

Pode seguir o tutorial Introdução para a sua plataforma móvel à sua escolha, ao implementar a parte de back-end no Python.

Nota

O âmbito do exemplo está limitado apenas ao envio de notificações e não faz qualquer gestão de registo.

Interface de cliente

A interface de cliente principal pode fornecer os mesmos métodos disponíveis no SDK dos Hubs de Notificação .NET. Esta interface permite-lhe traduzir diretamente todos os tutoriais e exemplos atualmente disponíveis neste site e contribuiu com a comunidade na Internet.

Pode encontrar todo o código disponível no exemplo de wrapper REST do Python.

Por exemplo, para criar um cliente:

isDebug = True
hub = NotificationHub("myConnectionString", "myNotificationHubName", isDebug)

Para enviar uma notificação de alerta do Windows:

wns_payload = """<toast><visual><binding template=\"ToastText01\"><text id=\"1\">Hello world!</text></binding></visual></toast>"""
hub.send_windows_notification(wns_payload)

Implementação

Se ainda não o fez, siga o tutorial Introdução até à última secção onde tem de implementar o back-end.

Todos os detalhes para implementar um wrapper REST completo podem ser encontrados no MSDN. Esta secção descreve a implementação do Python dos principais passos necessários para aceder aos pontos finais REST dos Hubs de Notificação e enviar notificações

  1. Analisar a cadeia de ligação
  2. Gerar o token de autorização
  3. Enviar uma notificação com a API REST de HTTP

Analisar a cadeia de ligação

Eis a classe principal que implementa o cliente, cujo construtor analisa a cadeia de ligação:

class NotificationHub:
    API_VERSION = "?api-version=2013-10"
    DEBUG_SEND = "&test"

    def __init__(self, connection_string=None, hub_name=None, debug=0):
        self.HubName = hub_name
        self.Debug = debug

        # Parse connection string
        parts = connection_string.split(';')
        if len(parts) != 3:
            raise Exception("Invalid ConnectionString.")

        for part in parts:
            if part.startswith('Endpoint'):
                self.Endpoint = 'https' + part[11:].lower()
            if part.startswith('SharedAccessKeyName'):
                self.SasKeyName = part[20:]
            if part.startswith('SharedAccessKey'):
                self.SasKeyValue = part[16:]

Criar token de segurança

Os detalhes da criação do token de segurança estão disponíveis aqui. Adicione os NotificationHub seguintes métodos à classe para criar o token com base no URI do pedido atual e nas credenciais extraídas da cadeia de ligação.

@staticmethod
def get_expiry():
    # By default returns an expiration of 5 minutes (=300 seconds) from now
    return int(round(time.time() + 300))


@staticmethod
def encode_base64(data):
    return base64.b64encode(data)


def sign_string(self, to_sign):
    key = self.SasKeyValue.encode('utf-8')
    to_sign = to_sign.encode('utf-8')
    signed_hmac_sha256 = hmac.HMAC(key, to_sign, hashlib.sha256)
    digest = signed_hmac_sha256.digest()
    encoded_digest = self.encode_base64(digest)
    return encoded_digest


def generate_sas_token(self):
    target_uri = self.Endpoint + self.HubName
    my_uri = urllib.parse.quote(target_uri, '').lower()
    expiry = str(self.get_expiry())
    to_sign = my_uri + '\n' + expiry
    signature = urllib.parse.quote(self.sign_string(to_sign))
    auth_format = 'SharedAccessSignature sig={0}&se={1}&skn={2}&sr={3}'
    sas_token = auth_format.format(signature, expiry, self.SasKeyName, my_uri)
    return sas_token

Enviar uma notificação com a API REST de HTTP

Nota

O Serviço de Notificações Push da Microsoft (MPNS) foi preterido e já não é suportado.

Primeiro, vamos utilizar definir uma classe que representa uma notificação.

class Notification:
    def __init__(self, notification_format=None, payload=None, debug=0):
        valid_formats = ['template', 'apple', 'gcm',
                         'windows', 'windowsphone', "adm", "baidu"]
        if not any(x in notification_format for x in valid_formats):
            raise Exception(
                "Invalid Notification format. " +
                "Must be one of the following - 'template', 'apple', 'gcm', 'windows', 'windowsphone', 'adm', 'baidu'")

        self.format = notification_format
        self.payload = payload

        # array with keynames for headers
        # Note: Some headers are mandatory: Windows: X-WNS-Type, WindowsPhone: X-NotificationType
        # Note: For Apple you can set Expiry with header: ServiceBusNotification-ApnsExpiry
        # in W3C DTF, YYYY-MM-DDThh:mmTZD (for example, 1997-07-16T19:20+01:00).
        self.headers = None

Esta classe é um contentor para um corpo de notificação nativo ou um conjunto de propriedades de uma notificação de modelo, um conjunto de cabeçalhos, que contém formato (plataforma nativa ou modelo) e propriedades específicas da plataforma (como propriedade de expiração da Apple e cabeçalhos WNS).

Veja a documentação das APIs REST dos Hubs de Notificação e os formatos das plataformas de notificação específicas para obter todas as opções disponíveis.

Agora, com esta classe, escreva os métodos de notificação de envio dentro da NotificationHub classe .

def make_http_request(self, url, payload, headers):
    parsed_url = urllib.parse.urlparse(url)
    connection = http.client.HTTPSConnection(
        parsed_url.hostname, parsed_url.port)

    if self.Debug > 0:
        connection.set_debuglevel(self.Debug)
        # adding this querystring parameter gets detailed information about the PNS send notification outcome
        url += self.DEBUG_SEND
        print("--- REQUEST ---")
        print("URI: " + url)
        print("Headers: " + json.dumps(headers, sort_keys=True,
                                       indent=4, separators=(' ', ': ')))
        print("--- END REQUEST ---\n")

    connection.request('POST', url, payload, headers)
    response = connection.getresponse()

    if self.Debug > 0:
        # print out detailed response information for debugging purpose
        print("\n\n--- RESPONSE ---")
        print(str(response.status) + " " + response.reason)
        print(response.msg)
        print(response.read())
        print("--- END RESPONSE ---")

    elif response.status != 201:
        # Successful outcome of send message is HTTP 201 - Created
        raise Exception(
            "Error sending notification. Received HTTP code " + str(response.status) + " " + response.reason)

    connection.close()


def send_notification(self, notification, tag_or_tag_expression=None):
    url = self.Endpoint + self.HubName + '/messages' + self.API_VERSION

    json_platforms = ['template', 'apple', 'gcm', 'adm', 'baidu']

    if any(x in notification.format for x in json_platforms):
        content_type = "application/json"
        payload_to_send = json.dumps(notification.payload)
    else:
        content_type = "application/xml"
        payload_to_send = notification.payload

    headers = {
        'Content-type': content_type,
        'Authorization': self.generate_sas_token(),
        'ServiceBusNotification-Format': notification.format
    }

    if isinstance(tag_or_tag_expression, set):
        tag_list = ' || '.join(tag_or_tag_expression)
    else:
        tag_list = tag_or_tag_expression

    # add the tags/tag expressions to the headers collection
    if tag_list != "":
        headers.update({'ServiceBusNotification-Tags': tag_list})

    # add any custom headers to the headers collection that the user may have added
    if notification.headers is not None:
        headers.update(notification.headers)

    self.make_http_request(url, payload_to_send, headers)


def send_apple_notification(self, payload, tags=""):
    nh = Notification("apple", payload)
    self.send_notification(nh, tags)


def send_google_notification(self, payload, tags=""):
    nh = Notification("gcm", payload)
    self.send_notification(nh, tags)


def send_adm_notification(self, payload, tags=""):
    nh = Notification("adm", payload)
    self.send_notification(nh, tags)


def send_baidu_notification(self, payload, tags=""):
    nh = Notification("baidu", payload)
    self.send_notification(nh, tags)


def send_mpns_notification(self, payload, tags=""):
    nh = Notification("windowsphone", payload)

    if "<wp:Toast>" in payload:
        nh.headers = {'X-WindowsPhone-Target': 'toast',
                      'X-NotificationClass': '2'}
    elif "<wp:Tile>" in payload:
        nh.headers = {'X-WindowsPhone-Target': 'tile',
                      'X-NotificationClass': '1'}

    self.send_notification(nh, tags)


def send_windows_notification(self, payload, tags=""):
    nh = Notification("windows", payload)

    if "<toast>" in payload:
        nh.headers = {'X-WNS-Type': 'wns/toast'}
    elif "<tile>" in payload:
        nh.headers = {'X-WNS-Type': 'wns/tile'}
    elif "<badge>" in payload:
        nh.headers = {'X-WNS-Type': 'wns/badge'}

    self.send_notification(nh, tags)


def send_template_notification(self, properties, tags=""):
    nh = Notification("template", properties)
    self.send_notification(nh, tags)

Estes métodos enviam um pedido HTTP POST para o ponto final /messages do hub de notificação, com o corpo e cabeçalhos corretos para enviar a notificação.

Utilizar a propriedade de depuração para ativar o registo detalhado

Ativar a propriedade de depuração ao inicializar o Hub de Notificação escreve informações de registo detalhadas sobre o pedido HTTP e a informação de falha de sistema de resposta, bem como o resultado detalhado do envio de mensagens de Notificação. A propriedade TestSend dos Hubs de Notificação devolve informações detalhadas sobre o resultado do envio da notificação. Para utilizá-lo - inicialize com o seguinte código:

hub = NotificationHub("myConnectionString", "myNotificationHubName", isDebug)

Como resultado, o URL http do pedido de envio do Hub de Notificação é anexado com uma cadeia de consulta "test".

Concluir o tutorial

Agora, pode concluir o tutorial Introdução ao enviar a notificação a partir de um back-end do Python.

Inicialize o cliente dos Notification Hubs (substitua a cadeia de ligação e o nome do hub conforme indicado no tutorial Introdução):

hub = NotificationHub("myConnectionString", "myNotificationHubName")

Em seguida, adicione o código de envio consoante a sua plataforma móvel de destino. Este exemplo também adiciona métodos de nível superior para permitir o envio de notificações com base na plataforma, por exemplo, send_windows_notification para windows; send_apple_notification (para maçã), etc.

Loja Windows e Windows Phone 8.1 (não Silverlight)

wns_payload = """<toast><visual><binding template=\"ToastText01\"><text id=\"1\">Test</text></binding></visual></toast>"""
hub.send_windows_notification(wns_payload)

Windows Phone 8.0 e 8.1 Silverlight

hub.send_mpns_notification(toast)

iOS

alert_payload = {
    'data':
        {
            'msg': 'Hello!'
        }
}
hub.send_apple_notification(alert_payload)

Android

gcm_payload = {
    'data':
        {
            'msg': 'Hello!'
        }
}
hub.send_google_notification(gcm_payload)

Fogo Kindle

adm_payload = {
    'data':
        {
            'msg': 'Hello!'
        }
}
hub.send_adm_notification(adm_payload)

Baidu

baidu_payload = {
    'data':
        {
            'msg': 'Hello!'
        }
}
hub.send_baidu_notification(baidu_payload)

A execução do código Python deve produzir uma notificação apresentada no seu dispositivo de destino.

Exemplos

Ativar a debug propriedade

Quando ativa o sinalizador de depuração ao inicializar o NotificationHub, verá informações detalhadas sobre o pedido HTTP e a informação de falha de sistema de resposta, bem como NotificationOutcome, da seguinte forma, onde pode compreender que cabeçalhos HTTP são transmitidos no pedido e que resposta HTTP foi recebida do Hub de Notificação:

Captura de ecrã a mostrar uma consola com detalhes das mensagens de pedido e de resposta H T T P e Resultados da Notificação descritas a vermelho.

Pode ver o resultado detalhado do Hub de Notificação, por exemplo.

  • quando a mensagem é enviada com êxito para o Serviço de Notificações Push. 
    <Outcome>The Notification was successfully sent to the Push Notification System</Outcome>
  • Se não forem encontrados destinos para qualquer notificação push, é provável que veja o seguinte resultado como a resposta (o que indica que não foram encontrados registos para entregar a notificação, provavelmente porque os registos tinham algumas etiquetas desajustadas)
    '<NotificationOutcome xmlns="http://schemas.microsoft.com/netservices/2010/10/servicebus/connect" xmlns:i="https://www.w3.org/2001/XMLSchema-instance"><Success>0</Success><Failure>0</Failure><Results i:nil="true"/></NotificationOutcome>'

Difundir notificação de alerta para o Windows

Repare nos cabeçalhos que são enviados quando envia uma notificação de alerta de difusão para o cliente Windows.

hub.send_windows_notification(wns_payload)

Captura de ecrã de uma consola com detalhes sobre o pedido H T T P e o Formato de Notificação do Service Bus e os valores X W N S Type descritos a vermelho.

Enviar notificação especificando uma etiqueta (ou expressão de etiqueta)

Repare no cabeçalho HTTP de Etiquetas, que é adicionado ao pedido HTTP (no exemplo abaixo, a notificação é enviada apenas para registos com payload "sports")

hub.send_windows_notification(wns_payload, "sports")

Captura de ecrã de uma consola com detalhes sobre o pedido H T T P e o Formato de Notificação do Service Bus, uma Etiqueta de Notificação do Service Bus e valores de Tipo X W N S descritos a vermelho.

Enviar notificação especificando várias etiquetas

Repare como o cabeçalho HTTP de Etiquetas é alterado quando são enviadas várias etiquetas.

tags = {'sports', 'politics'}
hub.send_windows_notification(wns_payload, tags)

Captura de ecrã a mostrar uma consola com detalhes sobre o pedido H T T P e o Formato de Notificação do Service Bus, várias Etiquetas de Notificação do Service Bus e valores de Tipo X W N S descritos a vermelho.

Notificação com modelo

Repare que o cabeçalho Formatar HTTP é alterado e o corpo do payload é enviado como parte do corpo do pedido HTTP:

Lado do cliente - modelo registado:

var template = @"<toast><visual><binding template=""ToastText01""><text id=""1"">$(greeting_en)</text></binding></visual></toast>";

Lado do servidor – a enviar o payload:

template_payload = {'greeting_en': 'Hello', 'greeting_fr': 'Salut'}
hub.send_template_notification(template_payload)

Captura de ecrã de uma consola com detalhes sobre o pedido H T T P e os valores Tipo de conteúdo e Formato de Notificação do Service Bus descritos a vermelho.

Passos Seguintes

Este artigo mostrou como criar um cliente REST do Python para Hubs de Notificação. A partir daqui, pode: