django-restit 4.2.178__tar.gz → 4.2.180__tar.gz

{django_restit-4.2.178 → django_restit-4.2.180}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: django-restit
-Version: 4.2.178
+Version: 4.2.180
 Summary: A Rest Framework for DJANGO
 License: MIT
 Author: Ian Starnes

{django_restit-4.2.178 → django_restit-4.2.180}/account/models/member.py

@@ -357,7 +357,7 @@ class Member(User, RestModel, MetaDataModel):
             self.log("login_blocked", "password has expired", request, method="login", level=31)
             if throw_exception:
                 raise PermissionDeniedException(
-                    "password expired", 412,
+                    f"{self.username} password expired", 412,
                     component="account.Member", component_id=self.id)
             return False
         return True

{django_restit-4.2.178 → django_restit-4.2.180}/account/rpc/auth.py

@@ -84,9 +84,10 @@ def on_complete_jwt(request, member, method="basic"):
     request.device_id = device_id
     request.buid = request.DATA.get("__buid__", None)
     request.auth_session = am.AuthSession.NewSession(request, method)
+    if not bool(device_id) and bool(request.buid):
+        device_id = request.buid
     if bool(device_id):
         am.MemberDevice.register(request, member, device_id)
-
     request.jwt_token = token.access_token  # this tells the middleware to store in cookie
     return rv.restGet(
         request,

{django_restit-4.2.178 → django_restit-4.2.180}/inbox/utils/parsing.py

@@ -131,7 +131,7 @@ def toFileObject(attachment):
     return obj
 
 
-def parseAddresses(input_string, force_name=False):
+def parseAddresses(input_string, force_name=False, emails_only=False):
     if input_string is None:
         return []
     # Define a regex pattern to capture email addresses
@@ -153,6 +153,8 @@ def parseAddresses(input_string, force_name=False):
         else:
             name = None
         parsed_emails.append(objict(name=name, email=addr, full_email=full_email))
+    if emails_only:
+        return [email.email for email in parsed_emails]
     return parsed_emails
 
 
@@ -164,4 +166,3 @@ def toString(value):
     elif isinstance(value, (int, float)):
         value = str(value)
     return value
-

{django_restit-4.2.178 → django_restit-4.2.180}/incident/models/event.py

@@ -129,85 +129,135 @@ class Event(JSONMetaData, rm.RestModel):
             value = value[:80] + "..."
         self.description = value
 
-    def on_rest_pre_save(self, request):
+
+    def on_rest_created(self, request):
+        # Record metrics if enabled
+        if INCIDENT_EVENT_METRICS:
+            self._record_event_metrics()
+
+        self._update_properties(request)
+        # Process rules and create incident if needed
+        hit_rule = self.runRules()
+        incident = self._process_rules_and_create_incident(hit_rule)
+
+        if incident is None:
+            # No incident needed based on rules
+            return
+
+        # Update incident metadata
+        self.incident = incident
+        self.save()
+
+        # Record incident metrics if enabled
+        if INCIDENT_METRICS:
+            self._record_incident_metrics()
+
+        # Trigger any incident actions
+        try:
+            incident.triggerAction()
+        except Exception:
+            logger.exception()
+
+    def _update_properties(self, request):
+        # make sure hostname is set
         if self.hostname is None:
             self.hostname = settings.HOSTNAME
+
+        # Update properties
+        self.setProperty("level", self.level)
+        self.setProperty("category", self.category)
         if not self.getProperty("hostname", None):
             self.setProperty("hostname", self.hostname)
-        self.setProperty("category", self.category)
+
+        # lookup IP
         if request and request.DATA.get("ip_lookup", field_type=bool):
             self.reporter_ip = request.ip
             self.lookupIP(request.ip)
 
-    def on_rest_saved(self, request, is_new=False):
-        if not is_new:
-            return
-        if INCIDENT_EVENT_METRICS:
-            if self.hostname:
-                metrics.metric(f"incident_evt_{self.hostname}", category="incident_events", min_granularity="hourly")
-            metrics.metric("incident_evt", min_granularity=INCIDENT_EVENT_GRANULARITY)
+    def _record_event_metrics(self):
+        """Record event metrics"""
+        if self.hostname:
+            metrics.metric(
+                f"incident_evt_{self.hostname}",
+                category="incident_events",
+                min_granularity="hourly"
+            )
+        metrics.metric(
+            "incident_evt",
+            min_granularity=INCIDENT_EVENT_GRANULARITY
+        )
 
-        self.setProperty("level", self.level)
-        if request is not None:
-            self.reporter_ip = request.ip
-        # run through rules for the category
-        hit_rule = self.runRules()
-        priority = 10
-        incident = None
-        action_count = 0
+    def _record_incident_metrics(self):
+        """Record incident metrics"""
+        if self.hostname:
+            metrics.metric(
+                f"incidents_{self.hostname}",
+                category="incidents",
+                min_granularity="hourly"
+            )
+        metrics.metric(
+            "incidents",
+            min_granularity=INCIDENT_EVENT_GRANULARITY
+        )
+
+    def _process_rules_and_create_incident(self, hit_rule):
+        """Process rules and create incident if needed"""
         if hit_rule is not None:
-            # logger.error(f"RULE HIT: {hit_rule.name}")
-            priority = hit_rule.priority
+            # Handle rule matches
             if hit_rule.action == "ignore":
                 self.save()
-                return
+                return None
+
             if hit_rule.bundle > 0:
-                incident = Incident.getBundled(rule=hit_rule, event=self)
+                return Incident.getBundled(rule=hit_rule, event=self)
 
         elif self.level >= EVENT_TO_INCIDENT_LEVEL:
-            # we ignore levels 4 and higher if they did not create a rule
+            # Ignore high levels without rules
             self.save()
-            # logger.info(f"ignore event {self.pk} {self.description}")
-            return
+            return None
 
-        # always create an incident
-        if incident is None:
-            incident = Incident(
-                rule=hit_rule, priority=priority,
-                reporter_ip=self.reporter_ip,
-                category=self.category,
-                group=self.group,
-                component=self.component,
-                component_id=self.component_id,
-                hostname=self.hostname)
-            if self.group is None and hit_rule is not None:
-                incident.group = hit_rule.group
-            if hit_rule is not None and hit_rule.action_after != 0:
-                incident.state = INCIDENT_STATE_PENDING
-            # TODO possibly make this smarter?
-            if hit_rule and hit_rule.title_template and "{" in hit_rule.title_template:
-                try:
-                    incident.description = hit_rule.title_template.format(event=self)
-                except Exception:
-                    logger.exception(hit_rule.title_template)
-                    incident.description = self.description
-            elif self.category == "ossec":
-                incident.description = f"{self.hostname}: {self.description}"
-                incident.save()
-                incident.updateAbuseInfo()
-            else:
+        # Create new incident
+        return self._create_incident(hit_rule)
+
+    def _create_incident(self, hit_rule):
+        """Create a new incident"""
+        incident = Incident(
+            rule=hit_rule,
+            priority=hit_rule.priority if hit_rule else 10,
+            reporter_ip=self.reporter_ip,
+            category=self.category,
+            group=self.group,
+            component=self.component,
+            component_id=self.component_id,
+            hostname=self.hostname
+        )
+
+        # Set incident group from rule if needed
+        if self.group is None and hit_rule is not None:
+            incident.group = hit_rule.group
+
+        # Set pending state if rule requires
+        if hit_rule is not None and hit_rule.action_after != 0:
+            incident.state = INCIDENT_STATE_PENDING
+
+        # Set description based on rules and category
+        self._set_incident_description(incident, hit_rule)
+
+        incident.save()
+        incident.updateMeta(self)
+        return incident
+
+    def _set_incident_description(self, incident, hit_rule):
+        """Set the incident description"""
+        if hit_rule and hit_rule.title_template and "{" in hit_rule.title_template:
+            try:
+                incident.description = hit_rule.title_template.format(event=self)
+            except Exception:
+                logger.exception(hit_rule.title_template)
                 incident.description = self.description
+        elif self.category == "ossec":
+            incident.description = f"{self.hostname}: {self.description}"
             incident.save()
-            incident.updateMeta(self)
-        self.incident = incident
-        self.save()
-        if INCIDENT_METRICS:
-            # we want to track any incidents, including bundles
-            if self.hostname:
-                metrics.metric(f"incidents_{self.hostname}", category="incidents", min_granularity="hourly")
-            metrics.metric("incidents", min_granularity=INCIDENT_EVENT_GRANULARITY)
-
-        try:
-            incident.triggerAction()
-        except Exception:
-            logger.exception()
+            incident.updateAbuseInfo()
+        else:
+            incident.description = self.description

{django_restit-4.2.178 → django_restit-4.2.180}/pyproject.toml

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

{django_restit-4.2.178 → django_restit-4.2.180}/rest/__init__.py

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

{django_restit-4.2.178 → django_restit-4.2.180}/rest/decorators.py

@@ -62,7 +62,7 @@ def rest_error_catcher(func, request, *args, **kwargs):
                 metrics.metric(f"rest_call_{slug_path}", category="rest_calls", min_granularity=REST_METRICS_GRANULARITY)
         return func(request, *args, **kwargs)
     except PermissionDeniedException as err:
-        return rv.restPermissionDenied(request, err.reason, err.code)
+        return rv.restPermissionDenied(request, err.reason, err.code, component=err.component, component_id=err.component_id)
     except RestError as err:
         rh.log_exception("REST ERROR", request.path, err.reason)
         if settings.get("REST_ERROR_METRICS", True):
@@ -437,4 +437,3 @@ def periodic(minute=None, hour=None, day=None, month=None, weekday=None, tz=None
         inner_func.is_periodic = True
         return inner_func
     return decorator
-

{django_restit-4.2.178 → django_restit-4.2.180}/wiki/renderers/__init__.py

@@ -2,14 +2,23 @@ from .mistune.highlight import HighlightMixin
 from .mistune.toc import TocMixin
 from .mistune.media import MediaMixin
 import mistune
+import re
+
 try:
     HTMLRenderer = mistune.HTMLRenderer
 except Exception:
     HTMLRenderer = mistune.Renderer
 
 
+def slugify(text):
+    return re.sub(r'\W+', '-', text.strip().lower()).strip('-')
+
 class WikiRenderer(TocMixin, HighlightMixin, MediaMixin, HTMLRenderer):
     def __init__(self, *args, **kwargs):
         # self.enable_math()
         self.reset_toc()
         super(WikiRenderer, self).__init__(*args, **kwargs)
+
+    def heading(self, text, level):
+        slug = slugify(text)
+        return f'<h{level} id="{slug}">{text}</h{level}>\n'

{django_restit-4.2.178 → django_restit-4.2.180}/wiki/renderers/mistune/media.py

@@ -48,10 +48,11 @@ class MediaMixin(object):
         params = {"href":href}
         if title:
             params["title"] = title
-        if label:
-            params["download"] = label
-        if not href.startswith("http"):
+
+        if not href.startswith("http") and not href.startswith("#"):
             params["data-action"] = "local_page"
+        elif label and href.startswith("http"):
+            params["download"] = label
         flat_params = ' '.join("{}='{}'".format(key,val) for (key,val) in list(params.items()))
         return """<a {}>{}</a>""".format(flat_params, (text or link))
 
@@ -87,4 +88,3 @@ class MediaMixin(object):
 
         flat_params = ' '.join("{}='{}'".format(key,val) for (key,val) in list(params.items()))
         return '<img {} />'.format(flat_params)
-