cone.firebase 0.1__py3-none-any.whl

cone/firebase/__init__.py

@@ -0,0 +1,87 @@
+from cone.app import main_hook
+from cone.app.interfaces import IAuthenticator
+from cone.firebase.authentication import FirebaseAuthenticator
+from cone.ugm.browser.principal import user_field
+from yafowil.base import factory
+import firebase_admin
+import json
+import logging
+
+
+logger = logging.getLogger('cone.firebase')
+
+
+class FirebaseConfig(object):
+    web_api_key = None
+    service_account_json = None
+
+    def __init__(self, web_api_key, service_account_json_file):
+        self.web_api_key = web_api_key
+        with open(service_account_json_file, 'r') as f:
+            self.service_account_json = json.loads(f.read())
+
+
+# FirebaseConfig singleton
+config = None
+
+
+def load_firebase_config(settings):
+    global config
+    config = FirebaseConfig(
+        settings['firebase.web_api_key'],
+        settings['firebase.service_account_json_file']
+    )
+
+
+def initialize_firebase_admin():
+    service_account_json = config.service_account_json
+    cred = firebase_admin.credentials.Certificate(service_account_json)
+    if not firebase_admin._apps:
+        firebase_admin.initialize_app(cred)
+
+
+@user_field('firebase_user')
+def firebase_user_field_factory(form, label, value):
+    return factory(
+        'field:label:help:error:checkbox',
+        value=value,
+        props={
+            'label': label,
+            'datatype': bool,
+            'help': "shall this user also be managed in Firebase?",
+        })
+
+
+@user_field('email_verified')
+def email_verified(form, label, value):
+    return factory(
+        'field:label:help:error:checkbox',
+        value=value,
+        props={
+            'label': label,
+            'datatype': bool,
+            'help': "is user verified by email?",
+        })
+
+
+@user_field('fullname')
+def fullname_field_factory(form, label, value):
+    return factory(
+        'field:label:error:text',
+        value=value,
+        props={
+            'label': label,
+            'datatype': str,
+            'required': "fullname not given"
+        })
+
+
+@main_hook
+def initialize_firebase(config, global_config, settings):
+    load_firebase_config(settings)
+    initialize_firebase_admin()
+    config.registry.registerUtility(
+        FirebaseAuthenticator,
+        IAuthenticator,
+        'firebase'
+    )

cone/firebase/api.py

@@ -0,0 +1,5 @@
+from cone.firebase.management import get_device_tokens_for_user  # noqa
+from cone.firebase.management import register_device_token_for_user  # noqa
+from cone.firebase.messaging import send_message  # noqa
+from cone.firebase.messaging import send_message_to_user  # noqa
+from cone.firebase.messaging import send_messages  # noqa

cone/firebase/authentication.py

@@ -0,0 +1,76 @@
+from cone.app import security
+from cone.app import ugm_backend
+from cone.app.interfaces import IAuthenticator
+from zope.interface import implementer
+import cone.firebase
+import json
+import requests
+
+
+REST_API_URL_LOGIN = f"https://identitytoolkit.googleapis.com/v1/accounts:signInWithPassword"
+
+
+def sign_in_with_email_and_password(email, password, api_key, return_secure_token = True):
+    """
+    borrowed from here:
+    https://github.com/billydh/python-firebase-admin-sdk-demo/blob/master/sign_in_with_email_and_password.py
+    """
+
+    try:
+        payload = json.dumps({
+            "email": email or "",
+            "password": password or "",
+            "returnSecureToken": return_secure_token
+        })
+    except Exception as ex:
+        cone.firebase.logger.error(f"error encoding email: {email} and password: {password}")
+        raise
+
+    r = requests.post(REST_API_URL_LOGIN,
+                      params={"key": api_key},
+                      data=payload)
+
+    return r.json()
+
+
+@implementer(IAuthenticator)
+class FirebaseAuthenticator:
+
+    @classmethod
+    def authenticate(cls, uid: str, pwd: str) -> str:
+        """
+        does firebase authentication and in the case of success
+        checks if the uid exists in self.users, if not it creates the user there
+        when fb login is unsuccessful delegates it to
+        :return: login of logged in user
+        """
+
+        res = sign_in_with_email_and_password(uid, pwd, cone.firebase.config.web_api_key)
+
+        ugm = ugm_backend.ugm
+        users = ugm.users
+
+        if res.get("kind") == 'identitytoolkit#VerifyPasswordResponse':
+            id = res["localId"]
+            if id not in users:
+                users.create(
+                    id,
+                    login="email",
+                    email=res["email"],
+                    fullname=res.get("displayName"),
+                    registered=res["registered"],
+                    idtoken=res["idToken"]
+                )
+            # else:
+            #    user email aktualisieren
+
+            user = users[id]
+            if hasattr(users, "on_authenticated"):
+                users.on_authenticated(res["localId"])
+            # user.passwd(None, pwd)  # it is to decide if we need local pwds
+            return id
+        else:
+            # if not found in firebase login locally
+            auth = users.authenticate(uid, pwd)
+            if auth:
+                return uid

cone/firebase/management.py

@@ -0,0 +1,181 @@
+from cone.app import ugm_backend
+from cone.ugm.events import UserCreatedEvent
+from cone.ugm.events import UserDeletedEvent
+from cone.ugm.events import UserModifiedEvent
+from firebase_admin import auth
+from firebase_admin.auth import UserNotFoundError
+from pyramid.security import remember
+from typing import List
+from typing import Tuple
+from yafowil.base import ExtractionError
+from zope.event import classhandler
+import cone.firebase
+
+
+FIREBASE_DEVICE_TOKENS = "firebase_device_tokens"
+
+
+@classhandler.handler(UserCreatedEvent)
+def on_user_created(event: UserCreatedEvent):
+    user = event.principal
+    email = user.attrs["mail"]
+    uid = user.attrs["id"]
+    # if firebase_user checkbox is not installed, we want to add all users to FB
+    if "firebase_user" not in user.attrs or user.attrs["firebase_user"]:
+        if email:
+            user_record = create_firebase_user(user, event.password)
+            cone.firebase.logger.info(f"user {uid} added to firebase with email {email} -> {user_record.__dict__}")
+        else:
+            cone.firebase.logger.warn(f"user {uid} has no email -> not added to firebase")
+
+
+def create_firebase_user(user, password):
+    fullname = user.attrs["fullname"]
+    user_record = auth.create_user(
+        uid=user.attrs["id"],
+        email=user.attrs["mail"],
+        # phone_number='+15555550100',
+        # email_verified=True,
+        password=password,
+        display_name=fullname,
+        # photo_url='http://www.example.com/12345678/photo.png',
+        disabled=False
+    )
+    user.attrs["login"] = "mail"
+    return user_record
+
+
+@classhandler.handler(UserModifiedEvent)
+def on_user_modified(event: UserModifiedEvent):
+    user = event.principal
+    email = user.attrs["mail"]
+    uid = user.attrs["id"]
+    try:
+        fbuser = auth.get_user(uid)
+    except UserNotFoundError:
+        # user does not exist in firebase, lets push it to fb, the password has to be specified by hand, otherwise the
+        # hashed password will be set in fb!
+        if user.attrs.get("firebase_user", False):
+            cone.firebase.logger.warn(f"user wth id {uid} not found in firebase, creating it in fb")
+            if not user.attrs["fullname"]:
+                raise ExtractionError("Fullname not given")
+            fbuser = create_firebase_user(user, event.password)
+            cone.firebase.logger.warn(f"created user wth id {uid} in fb")
+        else:
+            fbuser = None
+            cone.firebase.logger.warn(f"user wth id {uid} not found in firebase")
+
+    if email and fbuser:
+        fullname = user.attrs["fullname"]
+        password = event.password
+
+        params = dict(
+            email=email,
+            # phone_number='+15555550100',
+            display_name=fullname,
+            disabled=False)
+
+        if event.password:
+            params["password"] = event.password
+
+        res = auth.update_user(
+            uid,
+            **params
+        )
+        cone.firebase.logger.info(f"user {uid} changes promoted to firebase with email {email} -> {res}")
+    else:
+        cone.firebase.logger.warn(f"user {uid} has no email -> not added to firebase")
+
+
+@classhandler.handler(UserDeletedEvent)
+def on_user_deleted(event):
+    user = event.principal
+    uid = user.attrs["id"]
+    try:
+        fbuser = auth.get_user(uid)
+        auth.delete_user(uid)
+        cone.firebase.logger.info(f"user with id {uid} deleted in firebase")
+    except UserNotFoundError:
+        cone.firebase.logger.warn(f"user with id {uid} not found in firebase -> user not deleted in fb")
+
+
+def authenticate_with_id_token(request, id_token: str) -> Tuple[str, str]:
+    """
+    uses the firebase ID token to login without password
+    needs installed UGM user folder located at AppRoot()["users"]
+
+    :return: tuple (user_id, auth token)
+    """
+    # users = AppRoot()["users"]
+    cone.firebase.logger.info(f"loggin in with firebase id token: {id_token}")
+    ugm = ugm_backend.ugm
+    users = ugm.users
+    res = auth.verify_id_token(id_token)
+    user_id = res["user_id"]
+    if user_id not in users:
+        # TODO: creation shall take place in security.authenticate()
+        cone.firebase.logger.info(f"user with id {user_id} not stored locally - creating")
+        users.create(
+            user_id,
+            login="email",
+            email=res["email"],
+            fullname=res.get("name", ""),
+            email_verified=res["email_verified"],
+            phone=res.get("phone_number", ""),
+            idtoken=id_token
+        )
+        cone.firebase.logger.info(f"user with {user_id} successfully created")
+
+    return user_id, remember(request, user_id)
+
+
+def register_device_token_for_user(login: str, token: str) -> List[str]:
+    """
+    registers a device token for a given user
+    :param login: email or uid
+    :param token: firebase device token
+    """
+    users = ugm_backend.ugm.users
+    if login not in users:
+        uid = users.id_for_login(login)
+    else:
+        uid = login
+
+    user = users[uid]
+    tokens = user.attrs.get(FIREBASE_DEVICE_TOKENS, []) or []
+    if token not in tokens:
+        user.attrs[FIREBASE_DEVICE_TOKENS] = list(tokens) + [token]
+
+    return user.attrs[FIREBASE_DEVICE_TOKENS]
+
+
+def unregister_device_token_for_user(login: str, token: str):
+    """
+    registers a device token for a given user
+    :param login: email or uid
+    :param token: firebase device token
+    """
+    users = ugm_backend.ugm.users
+    if login not in users:
+        uid = users.id_for_login(login)
+    else:
+        uid = login
+
+    user = users[uid]
+    tokens = user.attrs.get(FIREBASE_DEVICE_TOKENS, []) or []
+    if token in tokens:
+        user.attrs[FIREBASE_DEVICE_TOKENS] = [tok for tok in tokens if token != tok]
+
+
+def get_device_tokens_for_user(login: str) -> List[str]:
+    users = ugm_backend.ugm.users
+    if login not in users:
+        uid = users.id_for_login(login)
+    else:
+        uid = login
+
+    if uid in users:
+        user = users[uid]
+        return user.attrs.get(FIREBASE_DEVICE_TOKENS, []) or []
+    else:
+        return []

cone/firebase/messaging.py

@@ -0,0 +1,52 @@
+"""
+Firebase Messaging with cone
+
+docs see:
+https://firebase.google.com/docs/cloud-messaging/send-message
+"""
+from cone.app import ugm_backend
+from cone.firebase.management import get_device_tokens_for_user
+from cone.firebase.management import unregister_device_token_for_user
+from firebase_admin import messaging
+from firebase_admin.exceptions import InvalidArgumentError
+from firebase_admin.messaging import UnregisteredError
+from typing import Any
+from typing import Dict
+from typing import List
+import firebase_admin
+import logging
+
+
+logger = logging.getLogger('cone.firebase')
+
+
+def send_message(data: Dict[str, Any], token: str) -> str:
+    messaging = firebase_admin.messaging
+    message = messaging.Message(data=data, token=token)
+    response = messaging.send(message)
+    return response
+
+
+def send_messages(data: Dict[str, Any], tokens: List[str]):
+    messaging = firebase_admin.messaging
+    message = messaging.MulticastMessage(data=data, tokens=tokens)
+    response = messaging.send_multicast(message)
+    return response
+
+
+def send_message_to_user(login: str, data: Dict[str, Any]) -> List[str]:
+    tokens = get_device_tokens_for_user(login)
+    results = []
+    # return send_messages(data, tokens)
+    for token in tokens:
+        try:
+            res = send_message(data, token)
+            results.append(res)
+        except (UnregisteredError, InvalidArgumentError) as ex:
+            unregister_device_token_for_user(login, token)
+            logger.exception(f"error sending message to:{token}. the token is not registered in firebase, will be automatically unregistered")
+        except Exception as ex:
+            logger.exception(f"message to token {token} failed")
+            raise
+
+    return results

cone/firebase/testing/__init__.py

@@ -0,0 +1,133 @@
+from cone import firebase
+from cone.app.ugm import ugm_backend
+from cone.firebase import api
+from cone.firebase import authentication
+from cone.firebase import messaging
+from cone.firebase.testing import firebase_admin
+from cone.firebase.testing.firebase_admin import messaging as fb_fake_messaging
+from cone.ugm.events import UserCreatedEvent
+from cone.ugm.events import UserDeletedEvent
+from cone.ugm.events import UserModifiedEvent
+from cone.ugm.testing import localmanager_config
+from cone.ugm.testing import ugm_config
+from cone.ugm.testing import UGMLayer
+from zope.event import classhandler
+import json
+import os
+import shutil
+import tempfile
+
+
+service_account_json = {
+    'auth_provider_x509_cert_url': 'https://www.googleapis.com/oauth2/v1/certs',
+    'auth_uri': 'https://accounts.google.com/o/oauth2/auth',
+    'client_email': 'firebase-adminsdk-foo@example.iam.gserviceaccount.com',
+    'client_id': 'xxx',
+    'client_x509_cert_url': 'https://www.googleapis.com/robot/v1/metadata/x509/firebase-adminsdk-foo@example.iam.gserviceaccount.com',
+    'private_key': '-----BEGIN PRIVATE KEY-----\nxxx\n-----END PRIVATE KEY-----\n',
+    'private_key_id': 'xxx',
+    'project_id': 'example',
+    'token_uri': 'https://oauth2.googleapis.com/token',
+    'type': 'service_account'
+}
+
+
+def fake_sign_in_with_email_and_password(
+    email,
+    password,
+    api_key,
+    return_secure_token=True
+):
+    try:
+        res = firebase_admin.get_user_by_email(email)
+        res['kind'] = 'identitytoolkit#VerifyPasswordResponse'
+    except KeyError:
+        res = {
+            'error': {
+                'code': 400,
+                'message': 'INVALID_EMAIL',
+                'errors': [{
+                    'message': 'INVALID_EMAIL',
+                    'domain': 'global',
+                    'reason': 'invalid'
+                }]
+            }
+        }
+    return res
+
+
+class FirebaseLayer(UGMLayer):
+
+    def make_app(self):
+        ugm_users_file = os.path.join(self.ugm_dir, 'users')
+        ugm_groups_file = os.path.join(self.ugm_dir, 'groups')
+        ugm_roles_file = os.path.join(self.ugm_dir, 'roles')
+        ugm_datadir = os.path.join(self.ugm_dir, 'data')
+        # call direct to grandparent
+        super(UGMLayer, self).make_app(**{
+            'cone.plugins': '\n'.join([
+                'cone.ugm',
+                'cone.firebase'
+            ]),
+            'ugm.backend': 'file',
+            'ugm.config': ugm_config,
+            'ugm.localmanager_config': localmanager_config,
+            'ugm.users_file': ugm_users_file,
+            'ugm.groups_file': ugm_groups_file,
+            'ugm.roles_file': ugm_roles_file,
+            'ugm.datadir': ugm_datadir,
+            'firebase.web_api_key': 'xxxxxxxxxx',
+            'firebase.service_account_json_file': os.path.join(
+                self.tempdir,
+                'service_account.json'
+            )
+        })
+        ugm_backend.initialize()
+
+    def setUp(self, args=None):
+        self.patch_modules()
+        self.tempdir = tempfile.mkdtemp()
+        with open(os.path.join(self.tempdir, 'service_account.json'), 'w') as f:
+            f.write(json.dumps(service_account_json))
+        super(FirebaseLayer, self).setUp()
+        # create a firebase only user
+        firebase_admin.create_user(id="donald", login="email", email="donald@duck.com")
+        # create a local only user
+        users = ugm_backend.ugm.users
+        users.create(
+            "donald_local",
+            login="email",
+            email="donald_local@duck.com",
+            fullname="Donald Duck local",
+        )
+        users["donald_local"].passwd(None, "daisy1")
+        assert "donald_local" in users
+
+    def tearDown(self):
+        self.unpatch_modules()
+        self.unregister_handlers()
+        super(FirebaseLayer, self).tearDown()
+        shutil.rmtree(self.tempdir)
+        firebase_admin.delete_user("donald")
+
+    def patch_modules(self):
+        self.firebase_admin_orgin = firebase.firebase_admin
+        firebase.firebase_admin = firebase_admin
+        firebase.firebase_admin.messaging = fb_fake_messaging
+        api.firebase_admin = firebase_admin
+        messaging.firebase_admin = firebase_admin
+        self.sign_in_with_email_and_password = authentication.sign_in_with_email_and_password
+        authentication.sign_in_with_email_and_password = fake_sign_in_with_email_and_password
+
+    def unpatch_modules(self):
+        firebase.firebase_admin = self.firebase_admin_orgin
+        api.firebase_admin = self.firebase_admin_orgin
+        authentication.sign_in_with_email_and_password = self.sign_in_with_email_and_password
+
+    def unregister_handlers(self):
+        del classhandler.registry[UserCreatedEvent]
+        del classhandler.registry[UserDeletedEvent]
+        del classhandler.registry[UserModifiedEvent]
+
+
+firebase_layer = FirebaseLayer()

cone/firebase/testing/firebase_admin/__init__.py

@@ -0,0 +1,54 @@
+# faking the firebase auth api
+
+from . import credentials # noqua
+from . import messaging   # noqa
+
+_apps = None
+
+users_by_email = {}
+users_by_id = {}
+
+
+def delete_user(uid):
+    user = get_user(uid)
+    del users_by_email[user["email"]]
+    del users_by_id[uid]
+
+
+def get_user(uid):
+    return users_by_id[uid]
+
+
+def get_user_by_email(email):
+    return users_by_email[email]
+
+
+def update_user(uid, **kw):
+    user = users_by_id[uid]
+    user.update(**kw)
+
+
+def create_user(**kw):
+    id = kw.pop("id")
+    email = kw.pop("email")
+    if not id:
+        id = email
+
+    new_user = {
+        "localId": id,
+        "email": email,
+        "idToken": "xxx",
+        "profilePicture": "",
+        "refreshToken": "string",
+        "expiresIn": "",
+        "registered":True
+    }
+    new_user.update(**kw)
+    users_by_id[new_user["localId"]] = new_user
+    users_by_email[new_user["email"]] = new_user
+    return new_user
+
+
+def initialize_app(cred):
+    global _apps
+    _apps = True

cone/firebase/testing/firebase_admin/credentials.py

@@ -0,0 +1,4 @@
+class Certificate(object):
+
+    def __init__(self, service_account_json):
+        self.service_account_json = service_account_json

cone/firebase/testing/firebase_admin/messaging.py

@@ -0,0 +1,121 @@
+# Fake api for cloud messaging
+
+class Message:
+    """A message that can be sent via Firebase Cloud Messaging.
+
+    Contains payload information as well as recipient information. In particular, the message must
+    contain exactly one of token, topic or condition fields.
+
+    Args:
+        data: A dictionary of data fields (optional). All keys and values in the dictionary must be
+            strings.
+        notification: An instance of ``messaging.Notification`` (optional).
+        android: An instance of ``messaging.AndroidConfig`` (optional).
+        webpush: An instance of ``messaging.WebpushConfig`` (optional).
+        apns: An instance of ``messaging.ApnsConfig`` (optional).
+        fcm_options: An instance of ``messaging.FCMOptions`` (optional).
+        token: The registration token of the device to which the message should be sent (optional).
+        topic: Name of the FCM topic to which the message should be sent (optional). Topic name
+            may contain the ``/topics/`` prefix.
+        condition: The FCM condition to which the message should be sent (optional).
+    """
+
+    def __init__(self, data=None, notification=None, android=None, webpush=None, apns=None,
+                 fcm_options=None, token=None, topic=None, condition=None):
+        self.data = data
+        self.notification = notification
+        self.android = android
+        self.webpush = webpush
+        self.apns = apns
+        self.fcm_options = fcm_options
+        self.token = token
+        self.topic = topic
+        self.condition = condition
+
+    def __str__(self):
+        return json.dumps(self, cls=MessageEncoder, sort_keys=True)
+
+class MulticastMessage:
+    """A message that can be sent to multiple tokens via Firebase Cloud Messaging.
+
+    Args:
+        tokens: A list of registration tokens of targeted devices.
+        data: A dictionary of data fields (optional). All keys and values in the dictionary must be
+            strings.
+        notification: An instance of ``messaging.Notification`` (optional).
+        android: An instance of ``messaging.AndroidConfig`` (optional).
+        webpush: An instance of ``messaging.WebpushConfig`` (optional).
+        apns: An instance of ``messaging.ApnsConfig`` (optional).
+        fcm_options: An instance of ``messaging.FCMOptions`` (optional).
+    """
+    def __init__(self, tokens, data=None, notification=None, android=None, webpush=None, apns=None,
+                 fcm_options=None):
+        # _Validators.check_string_list('MulticastMessage.tokens', tokens)
+        if len(tokens) > 500:
+            raise ValueError('MulticastMessage.tokens must not contain more than 500 tokens.')
+        self.tokens = tokens
+        self.data = data
+        self.notification = notification
+        self.android = android
+        self.webpush = webpush
+        self.apns = apns
+        self.fcm_options = fcm_options
+
+
+class BatchResponse:
+    """The response received from a batch request to the FCM API."""
+
+    def __init__(self, responses):
+        self._responses = responses
+        self._success_count = len([resp for resp in responses if resp.success])
+
+    @property
+    def responses(self):
+        """A list of ``messaging.SendResponse`` objects (possibly empty)."""
+        return self._responses
+
+    @property
+    def success_count(self):
+        return self._success_count
+
+    @property
+    def failure_count(self):
+        return len(self.responses) - self.success_count
+
+
+class SendResponse:
+    """The response received from an individual batched request to the FCM API."""
+
+    def __init__(self, resp, exception):
+        self._exception = exception
+        self._message_id = None
+        if resp:
+            self._message_id = resp.get('name', None)
+
+    @property
+    def message_id(self):
+        """A message ID string that uniquely identifies the message."""
+        return self._message_id
+
+    @property
+    def success(self):
+        """A boolean indicating if the request was successful."""
+        return self._message_id is not None and not self._exception
+
+    @property
+    def exception(self):
+        """A ``FirebaseError`` if an error occurs while sending the message to the FCM service."""
+        return self._exception
+
+
+def send(message: Message, dry_run=False):
+    return 'projects/willholzen-293208/messages/0:1612781129630326%d758af2bf9fd7ecd'
+
+
+def send_multicast(message: Message, dry_run=False):
+    return BatchResponse(
+        [
+            SendResponse(
+                dict(name='projects/willholzen-293208/messages/0:1612781129630326%d758af2bf9fd7ecd'), None)
+        ]
+    )

cone/firebase/tests.py

@@ -0,0 +1,112 @@
+from cone import firebase
+from cone.app.ugm import ugm_backend
+from cone.firebase import messaging
+from cone.firebase import testing
+from cone.firebase.api import get_device_tokens_for_user
+from cone.firebase.api import register_device_token_for_user
+from cone.firebase.testing.firebase_admin import messaging as fb_fake_messaging
+from node.tests import NodeTestCase
+import sys
+import unittest
+
+
+EXAMPLE_DEVICE_TOKEN = (
+    'dtt9cGrcSXicn8mW0tvcTQ:APA91bHlcidOIQwXoXVa3p22fBDvgeu'
+    '1kUwElEKpdVcliODGAbtjviOV7Ruls2h__enWF1P_gZApIVOOfHKGl'
+    'Tft0vWuzzwGapsXbZIIH9s7-rbpilV4Hu_JzoLBYAwpCoP3Nkf3foPv'
+)
+
+
+class TestFirebase(NodeTestCase):
+    layer = testing.firebase_layer
+
+    def test_initialize_firebase(self):
+        self.assertIsInstance(firebase.config, firebase.FirebaseConfig)
+        self.assertEqual(firebase.config.web_api_key, 'xxxxxxxxxx')
+        self.assertEqual(
+            firebase.config.service_account_json,
+            testing.service_account_json
+        )
+
+    def test_firebase_authentication(self):
+        """Tests a login situation where only a firebase user exists and after
+        authentication is added to the local UGM database.
+        """
+        from cone.app import security
+        users = ugm_backend.ugm.users
+        request = self.layer.new_request()
+        security.AUTHENTICATOR = "firebase"
+        security.authenticate(request, "donald@duck.com", "daisy1")
+
+        # during the authentication the user should be added to UGM
+        self.assertTrue("donald" in users)
+
+    def test_local_authentication(self):
+        """Tests a local only login for the situation that a certain user is
+        only given locally and login should the fall back to standard auth
+        """
+        from cone.app import security
+        users = ugm_backend.ugm.users
+        self.assertTrue("donald_local" in users)
+
+        request = self.layer.new_request()
+        security.AUTHENTICATOR = "firebase"
+        security.authenticate(request, "donald_local", "daisy1")
+
+    def test_management(self):
+        """Test management of device tokens for firebase messaging
+        """
+        register_device_token_for_user("donald", EXAMPLE_DEVICE_TOKEN)
+        self.assertTrue(EXAMPLE_DEVICE_TOKEN in get_device_tokens_for_user("donald"))
+
+    def test_send_message(self):
+        registration_token = EXAMPLE_DEVICE_TOKEN
+        message = fb_fake_messaging.Message(
+            data={
+                'score': '850',
+                'time': '2:45',
+            },
+            token=registration_token,
+        )
+        res = fb_fake_messaging.send(message, dry_run=True)
+        assert res == 'projects/willholzen-293208/messages/0:1612781129630326%d758af2bf9fd7ecd'
+
+    def test_send_multicast_message(self):
+        registration_tokens = [EXAMPLE_DEVICE_TOKEN]
+        message = fb_fake_messaging.MulticastMessage(
+            data={'score': '850', 'time': '2:45'},
+            tokens=registration_tokens,
+        )
+        fb_fake_messaging.send_multicast(message)
+
+    def test_send_message_to_user(self):
+        data = {'score': '850', 'time': '2:45'}
+        res = messaging.send_message_to_user("donald", data)
+        self.assertTrue(res[0].startswith('projects/willholzen-293208/messages/'))
+
+
+def run_tests():
+    from cone.firebase import tests
+    from zope.testrunner.runner import Runner
+
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.findTestCases(tests))
+
+    runner = Runner(found_suites=[suite])
+    runner.run()
+    sys.exit(int(runner.failed))
+
+
+# def test_run_tests():
+#     from cone.firebase import tests
+#     from zope.testrunner.runner import Runner
+#
+#     suite = unittest.TestSuite()
+#     suite.addTest(unittest.findTestCases(tests))
+#
+#     runner = Runner(found_suites=[suite])
+#     runner.run()
+
+
+if __name__ == '__main__':
+    run_tests()

cone.firebase-0.1-py3.9-nspkg.pth

@@ -0,0 +1 @@
+import sys, types, os;p = os.path.join(sys._getframe(1).f_locals['sitedir'], *('cone',));importlib = __import__('importlib.util');__import__('importlib.machinery');m = sys.modules.setdefault('cone', importlib.util.module_from_spec(importlib.machinery.PathFinder.find_spec('cone', [os.path.dirname(p)])));m = m or sys.modules.setdefault('cone', types.ModuleType('cone'));mp = (m or []) and m.__dict__.setdefault('__path__',[]);(p not in mp) and mp.append(p)

cone_firebase-0.1.dist-info/METADATA

@@ -0,0 +1,146 @@
+Metadata-Version: 2.4
+Name: cone.firebase
+Version: 0.1
+Summary: Firebase integration for cone.app
+Home-page: http://github.com/conestack/cone.firebase
+Author: Cone Contributors
+Author-email: dev@conestack.org
+License: Simplified BSD
+Keywords: node pyramid cone web
+Classifier: Environment :: Web Environment
+Classifier: Programming Language :: Python
+Classifier: Topic :: Internet :: WWW/HTTP :: Dynamic Content
+License-File: LICENSE.rst
+Requires-Dist: proto-plus==1.18.1
+Requires-Dist: google-api-core==1.26.3
+Requires-Dist: google-api-python-client==2.2.0
+Requires-Dist: google-auth==1.29.0
+Requires-Dist: google-auth-httplib2==0.1.0
+Requires-Dist: google-auth-oauthlib==0.4.6
+Requires-Dist: google-cloud-core==1.6.0
+Requires-Dist: google-cloud-firestore==2.1.0
+Requires-Dist: google-cloud-storage==1.37.1
+Requires-Dist: google-crc32c==1.1.2
+Requires-Dist: google-pasta==0.2.0
+Requires-Dist: google-resumable-media==1.2.0
+Requires-Dist: googleapis-common-protos==1.53.0
+Requires-Dist: setuptools
+Requires-Dist: cone.app<1.1.0
+Requires-Dist: requests
+Requires-Dist: firebase_admin==4.5.3
+Provides-Extra: test
+Requires-Dist: zope.testrunner; extra == "test"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+.. image:: https://img.shields.io/pypi/v/cone.firebase.svg
+    :target: https://pypi.python.org/pypi/cone.firebase
+    :alt: Latest PyPI version
+
+.. image:: https://img.shields.io/pypi/dm/cone.firebase.svg
+    :target: https://pypi.python.org/pypi/cone.firebase
+    :alt: Number of PyPI downloads
+
+.. image:: https://travis-ci.org/bluedynamics/cone.firebase.svg?branch=master
+    :target: https://travis-ci.org/bluedynamics/cone.firebase
+
+.. image:: https://coveralls.io/repos/github/bluedynamics/cone.firebase/badge.svg?branch=master
+    :target: https://coveralls.io/github/bluedynamics/cone.firebase?branch=master
+
+
+This package provides a firebase integration in to cone.app.
+
+
+Installation
+------------
+
+Include ``cone.firebase`` to install dependencies in your application's
+``setup.py``.
+
+
+Configuration
+-------------
+
+Adopt your application config ini file to define firebase related API keys.
+
+.. code-block:: ini
+
+    [app:my_app]
+    use = egg:cone.app#main
+
+    cone.plugins =
+        cone.firebase
+
+    cone.authenticator = firebase
+
+    firebase.web_api_key = xxx
+    firebase.service_account_json_file = path/to/service_account.json
+
+also in your ugm.xml you can optionally add the `firebase_user` checkbox:
+
+.. code-block:: xml
+
+    <users_form_attrmap>
+        ...
+        <elem>
+            <key>firebase_user</key>
+            <value>Firebase User</value>
+        </elem>
+    </users_form_attrmap>
+
+When you want to upgrade an existing user to FB, you can do this by checking
+`firebase_user` in the user edit form, butt attention: you have to manually
+enter the password since the firebase API expects the password in cleartext.
+
+Contributors
+============
+
+- Robert Niederreiter
+- Phil Auersperg
+
+
+Changes
+=======
+
+0.1 (2025-10-25)
+----------------
+
+- Initial
+
+
+License
+=======
+
+Copyright (c) 2021, BlueDynamics Alliance, Austria
+Copyright (c) 2021, Cone Contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cone_firebase-0.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+cone.firebase-0.1-py3.9-nspkg.pth,sha256=WmSYeXqiFe1Qae-WQFmtUgaaYvduormqDUjrRgs1ASs,457
+cone/firebase/__init__.py,sha256=8Y5bVP_QZ-wPY8raovTb_df_cVEmOn5Gr0Lt5x76MfU,2242
+cone/firebase/api.py,sha256=XGsOZOnDwKkO5_SjNrUiKPPSE4ptTLZY0hv5v5wyEkw,328
+cone/firebase/authentication.py,sha256=e1bBvMBodSngpoXBM9_6t2_XEq8qOWKRXB3l0bxU16w,2433
+cone/firebase/management.py,sha256=EmbqLIJ0W57EHKG96SN_f7FgFwIygCegmhlr398bMs4,6044
+cone/firebase/messaging.py,sha256=9_HJ5rd60EZr-6LgubMi1B_1i_P_k51XD5Xl4JAlyXM,1733
+cone/firebase/tests.py,sha256=255kdmM2cwa8Rt2RCCtP316i_ipLnANLElnV0QQniY8,3830
+cone/firebase/testing/__init__.py,sha256=GFML_Gqtfw73XlAkaBdtXNMz1kL_BhLeuBkv2ivZ9Uk,4838
+cone/firebase/testing/firebase_admin/__init__.py,sha256=VaekqatvJ2iE1M0H0-mq8rREGf22847nMzYTzTDk72E,983
+cone/firebase/testing/firebase_admin/credentials.py,sha256=dWr3nlUtuiFuGN4WaqocNvbxjuS5CSw5KHxwutSOHws,131
+cone/firebase/testing/firebase_admin/messaging.py,sha256=l09gMD02BZvpxMrwaw37vhfZ4UWLfiFJq-lGFdbZVHI,4589
+cone_firebase-0.1.dist-info/licenses/LICENSE.rst,sha256=zaJbEi2UOhNjFLC1d2qra_JVlZceavFtt9yOXoM37Ng,1368
+cone_firebase-0.1.dist-info/METADATA,sha256=6Ghw_bY-Lm4UMjdIXZ0DYiSSQgRRllfhvHDG1kza8_0,4527
+cone_firebase-0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cone_firebase-0.1.dist-info/namespace_packages.txt,sha256=lu11VEz--UhjAtw-HG4CejJNFf-TZlq7z1O6wZ7Vrjk,5
+cone_firebase-0.1.dist-info/top_level.txt,sha256=lu11VEz--UhjAtw-HG4CejJNFf-TZlq7z1O6wZ7Vrjk,5
+cone_firebase-0.1.dist-info/RECORD,,

cone_firebase-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

cone_firebase-0.1.dist-info/licenses/LICENSE.rst

@@ -0,0 +1,27 @@
+License
+=======
+
+Copyright (c) 2021, BlueDynamics Alliance, Austria
+Copyright (c) 2021, Cone Contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+  list of conditions and the following disclaimer in the documentation and/or
+  other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

cone_firebase-0.1.dist-info/namespace_packages.txt

@@ -0,0 +1 @@
+cone

cone_firebase-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+cone