django-restit 4.2.61__tar.gz → 4.2.63__tar.gz

{django_restit-4.2.61 → django_restit-4.2.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-restit
-Version: 4.2.61
+Version: 4.2.63
 Summary: A Rest Framework for DJANGO
 License: MIT
 Author: Ian Starnes

django_restit-4.2.63/account/fcm/google.py

@@ -0,0 +1,53 @@
+import json
+import requests
+import time
+from jwt import JWT, jwk_from_dict
+from datetime import datetime, timedelta
+
+
+def oauthLogin(service_account_info):
+    # Token endpoint
+    token_uri = service_account_info["token_uri"]
+
+    # The current time and expiration time for the assertion
+    issued_at_time = datetime.utcnow()
+    expiration_time = issued_at_time + timedelta(minutes=60)
+
+    # JWT Header
+    jwt_header = {
+        "alg": "RS256",
+        "typ": "JWT",
+        "kid": service_account_info["private_key_id"]
+    }
+
+    # JWT Payload
+    jwt_payload = {
+        "iss": service_account_info["client_email"],
+        "sub": service_account_info["client_email"],
+        "aud": token_uri,
+        "iat": int(issued_at_time.timestamp()),
+        "exp": int(expiration_time.timestamp()),
+        "scope": "https://www.googleapis.com/auth/firebase.messaging"
+    }
+
+    # Create a JWT
+    jwt_instance = JWT()
+    private_key = jwk_from_dict({"k": service_account_info["private_key"], "kty": "RSA"})
+    assertion = jwt_instance.encode(jwt_header, jwt_payload, private_key)
+
+    # Exchange the JWT for an access token
+    response = requests.post(token_uri, data={
+        "grant_type": "urn:ietf:params:oauth:grant-type:jwt-bearer",
+        "assertion": assertion
+    })
+
+    response_data = response.json()
+
+    access_token = response_data.get("access_token")
+    expires_in = response_data.get("expires_in")  # Seconds until the token expires
+
+    # You can now use this access_token to authenticate requests to Google APIs.
+    # Remember to refresh the token using a similar process once it's close to expiration.
+
+    print("Access Token:", access_token)
+    print("Expires In:", expires_in)

django_restit-4.2.63/account/fcm/v1.py

@@ -0,0 +1,47 @@
+from google.oauth2 import service_account
+import google.auth.transport.requests
+import requests
+from rest import settings
+from rest import log
+
+
+FCM_ENDPOINT = 'https://fcm.googleapis.com/v1/projects/{}/messages:send'
+
+logger = log.getLogger("fcm", filename="fcm.log")
+
+
+def getCredentials(data):
+    # Load the credentials from the dictionary
+    credentials = service_account.Credentials.from_service_account_info(
+        data,
+        scopes=["https://www.googleapis.com/auth/firebase.messaging"])
+    # Use the credentials to authenticate a Requests session
+    auth_req = google.auth.transport.requests.Request()
+    credentials.refresh(auth_req)
+    return credentials
+
+
+def sendToDevice(device, data):
+    return sendData(device.cm_token, data)
+
+
+def sendNotification(to_token, title, body):
+    return postMessage(dict(token=to_token, notification=dict(title=title, body=body)))
+
+
+def sendData(to_token, data, priority="high"):
+    return postMessage(dict(token=to_token, data=data, content_available=True, priority=priority))
+
+
+def postMessage(credentials, payload):
+    logger.info("sending FCM", payload)
+    headers = {
+        'Authorization': 'Bearer ' + credentials.token,
+        'Content-Type': 'application/json; UTF-8',
+    }
+    body = dict(message=payload)
+    resp = requests.post(FCM_ENDPOINT.format(credentials.project_id), headers=headers, json=body)
+    logger.info("response", resp.text)
+    return resp
+
+

{django_restit-4.2.61 → django_restit-4.2.63}/account/models/device.py

@@ -1,6 +1,7 @@
 
 from django.db import models
 from rest import models as rm
+from rest import fields as rf
 from rest import settings
 from objict import objict
 from datetime import datetime
@@ -110,7 +111,36 @@ class MemberDeviceMetaData(rm.MetaDataBase):
     parent = models.ForeignKey(MemberDevice, related_name="properties", on_delete=models.CASCADE)
 
 
+class CloudCredentials(models.Model, rm.RestModel, rm.MetaDataModel):
+    """
+    MemberDevice Model tracks personal devices associated with a user.
+    This can include mobile and desktop devices.
+    """
+    created = models.DateTimeField(auto_now_add=True)
+    modified = models.DateTimeField(auto_now=True)
+    group = models.ForeignKey("account.Group", related_name="cloud_credentials", on_delete=models.CASCADE)
+
+    name = models.CharField(max_length=128, blank=True, null=True, default=None)
+    uuid = models.CharField(db_index=True, max_length=64, blank=True, null=True, default=None)
+    state = models.IntegerField(db_index=True, default=1)
+
+    credentials = rf.JSONField()
+
+    def sendToDevice(self, device, message):
+        pass
+
+    def sendNotification(self, token, title, body):
+        pass
+
+
+class CloudCredentialsMetaData(rm.MetaDataBase):
+    parent = models.ForeignKey(CloudCredentials, related_name="properties", on_delete=models.CASCADE)
+
+
 def getCloudMessanger(name):
+    creds = CloudCredentials.objects.filter(uuid=name).last()
+    if creds is not None:
+        return creds
     if name not in CM_BACKENDS:
         if name == "fcm":
             from account import fcm

{django_restit-4.2.61 → django_restit-4.2.63}/account/models/feeds.py

@@ -39,9 +39,9 @@ class GroupFeed(FeedBase, rm.RestModel):
         VIEW_PERMS = ["manage_groups", "manage_group", "view_all_groups"]
         GRAPHS = {
             "default": {
-                "recurse_into": ["generic__component"],
                 "graphs": {
-                    "member": "basic"
+                    "member": "basic",
+                    "generic__component": "basic"
                 }
             }
         }

django_restit-4.2.63/auditlog/cloudwatch.py

@@ -0,0 +1,93 @@
+import boto3
+import datetime
+import time
+import json
+from objict import objict
+from rest import settings
+from concurrent.futures import ThreadPoolExecutor
+
+
+LOG_CACHE = objict()
+
+
+def getClient():
+    if LOG_CACHE.client is None:
+        key = settings.AWS_KEY
+        secret = settings.AWS_SECRET
+        region = settings.AWS_REGION
+        LOG_CACHE.client = boto3.client("logs", aws_access_key_id=key, aws_secret_access_key=secret, region_name=region)
+    return LOG_CACHE.client
+
+
+def log(data, log_group, log_stream):
+    if LOG_CACHE.pool is None:
+        LOG_CACHE.pool = ThreadPoolExecutor(max_workers=1)
+    LOG_CACHE.pool.submit(logToCloudWatch, data, log_group, log_stream)
+    return True
+
+
+def logToCloudWatch(data, log_group, log_stream):
+    message = data
+    if isinstance(message, dict):
+        message = json.dumps(message)
+    return logBatchToCloudWatch([
+            dict(
+                timestamp=int(datetime.datetime.utcnow().timestamp() * 1000),
+                message=message)
+        ], log_group, log_stream)
+
+
+def logBatchToCloudWatch(batch, log_group, log_stream):
+    return getClient().put_log_events(
+        logGroupName=log_group,
+        logStreamName=log_stream,
+        logEvents=batch
+    )
+
+
+def getLogGroups():
+    response = getClient().describe_log_groups()
+    return response.get('logGroups', [])
+
+
+def createLogStream(log_group, log_stream):
+    try:
+        getClient().create_log_stream(logGroupName=log_group, logStreamName=log_stream)
+    except Exception:
+        pass  # Log stream already exists, no need to create it
+
+
+def getInsights(log_group, start_time, end_time, query_string):
+    """
+    Executes a CloudWatch Logs Insights query and returns the results.
+
+    :param log_group: The name of the log group to query.
+    :param start_time: The start time of the query (epoch time in seconds).
+    :param end_time: The end time of the query (epoch time in seconds).
+    :param query_string: The query string to use.
+    :param region_name: AWS region name.
+    :return: The query results.
+    """
+    # Create a CloudWatch Logs client
+    client = getClient()
+    
+    # Start the query
+    start_query_response = client.start_query(
+        logGroupName=log_group,
+        startTime=start_time,
+        endTime=end_time,
+        queryString=query_string,
+    )
+    
+    query_id = start_query_response['queryId']
+    
+    # Wait for the query to complete
+    response = None
+    while response is None or response['status'] == 'Running':
+        time.sleep(1)  # Sleep to rate limit the polling
+        response = client.get_query_results(queryId=query_id)
+    
+    if response['status'] == 'Complete':
+        return response['results']
+    else:
+        raise Exception(f"Query did not complete successfully. Status: {response['status']}")

{django_restit-4.2.61 → django_restit-4.2.63}/auditlog/models.py

@@ -8,6 +8,7 @@ import copy
 from rest.models import RestModel
 from rest import helpers
 from rest.log import getLogger
+from auditlog import cloudwatch
 
 import traceback
 
@@ -281,7 +282,9 @@ class PersistentLog(models.Model, RestModel):
 
     @staticmethod
     def log(message, level=0, request=None, component=None,
-            pkey=None, action=None, group=None, path=None, method=None, tid=None, no_truncate=False):
+            pkey=None, action=None, group=None, path=None,
+            method=None, tid=None, no_truncate=False,
+            aws_log_group=None, aws_log_stream=None):
         plog = PersistentLog.createLogFromRequest(
             request, component=component, tid=tid, pkey=pkey, action=action, group=group,
             path=path, method=method, level=level)
@@ -290,6 +293,8 @@ class PersistentLog(models.Model, RestModel):
 
         try:
             plog.save()
+            if aws_log_group and aws_log_stream:
+                cloudwatch.log(plog.toDict(), aws_log_group, aws_log_stream)
         except Exception:
             helpers.log_exception(plog.message)
 

{django_restit-4.2.61 → django_restit-4.2.63}/location/models/address.py

@@ -12,7 +12,7 @@ class Address(models.Model, rm.RestModel):
             "manage_group",
             "manage_settings"]
         CREATE_PERMS = None  # allow anyone to create
-        EDIT_PERMS = None  # allow anyone to edit
+        SAVE_PERMS = None  # allow anyone to edit
         GRAPHS = {
             "abstract": {
                 "fields":[

{django_restit-4.2.61 → django_restit-4.2.63}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "django-restit"
-version = "4.2.61"
+version = "4.2.63"
 description = "A Rest Framework for DJANGO"
 authors = ["Ian Starnes <ians@311labs.com>"]
 license = "MIT"

{django_restit-4.2.61 → django_restit-4.2.63}/rest/__init__.py

@@ -1,4 +1,4 @@
 from .uberdict import UberDict  # noqa: F401
 from .settings_helper import settings  # noqa: F401
 
-__version__ = "4.2.61"
+__version__ = "4.2.63"

{django_restit-4.2.61 → django_restit-4.2.63}/taskqueue/models.py

@@ -226,23 +226,25 @@ class Task(models.Model, RestModel):
         self.state = TASK_STATE_COMPLETED
         self.save()
 
-    def failed(self, reason=None):
+    def failed(self, reason=None, category="taskqueue_errors"):
         if reason and len(reason) > 250:
             reason = reason[:250]
         self.reason = reason
         self.state = TASK_STATE_FAILED
-        self.notifyError()
+        self.notifyError(category=category, reason=reason)
         self.save()
 
-    def notifyError(self):
-        handler = f"{self.model}{self.fname}"
+    def notifyError(self, category="taskqueue_errors", reason=None):
+        handler = f"{self.model}.{self.fname}"
         subject = f"TaskQueue - {handler}"
+        if reason is None:
+            reason = self.reason
 
-        msg = f"{handler}<br>\n{self.reason}"
+        msg = f"{handler}<br>\n{reason}"
         metadata = {
             "server": settings.get("HOSTNAME", "unknown"),
             "task": self.pk,
-            "reason": self.reason,
+            "reason": reason,
             "app": self.model,
             "fname": self.fname,
             "channel": self.channel,
@@ -253,6 +255,9 @@ class Task(models.Model, RestModel):
         if self.data:
             if self.data.url:
                 metadata["url"] = self.data.url
+                from urllib.parse import urlparse
+                purl = urlparse(self.data.url)
+                metadata["host"] = purl.netloc
                 msg = f"{msg}<br>\n{self.data.url}"
             if self.data.log_component:
                 metadata["component"] = self.data.log_component
@@ -261,7 +266,7 @@ class Task(models.Model, RestModel):
         try:
             import incident
             incident.event_now(
-                "taskqueue_errors", description=subject, details=msg, 
+                category, description=subject, details=msg, 
                 level=3, metadata=metadata)
         except Exception as err:
             self.log(str(err), kind="error")

{django_restit-4.2.61 → django_restit-4.2.63}/taskqueue/transports/http.py

@@ -15,9 +15,13 @@ def REQUEST(task):
                            data=task.data.data, raw_response=True,
                            verify=False, timeout=REQ_TIMEOUT)
         task.log(resp.text, kind="response")
-        return resp.status_code == 200
+        if resp.status_code == 200:
+            return True
+        task.reason = f"invalid response of {resp.status_code}"
     except requests.Timeout:
+        task.reason = "request timed out"
         task.log("request timed out", kind="error")
     except Exception as err:
+        task.reason = str(err)
         task.log_exception(err)
     return False

{django_restit-4.2.61 → django_restit-4.2.63}/taskqueue/worker.py

@@ -198,6 +198,8 @@ class WorkManager(object):
             task.completed()
         elif task.attempts < task.max_attempts:
             # -1 will auto calculate retry with back off
+            # lets report the issue
+            task.notifyError(reason=task.reason)
             task.retry_later(from_now_secs=-1)
         else:
             task.failed("max attempts")