arthexis 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

core/models.py

@@ -9,12 +9,13 @@ from django.db.models.functions import Lower
 from django.conf import settings
 from django.contrib.auth import get_user_model
 from django.utils.translation import gettext_lazy as _
-from django.core.validators import RegexValidator
+from django.core.validators import MaxValueValidator, MinValueValidator, RegexValidator
 from django.core.exceptions import ValidationError
 from django.apps import apps
 from django.db.models.signals import m2m_changed, post_delete, post_save
 from django.dispatch import receiver
-from datetime import timedelta
+from django.views.decorators.debug import sensitive_variables
+from datetime import time as datetime_time, timedelta
 from django.contrib.contenttypes.models import ContentType
 import hashlib
 import os
@@ -38,8 +39,13 @@ xmlrpc_client = defused_xmlrpc.xmlrpc_client
 
 from .entity import Entity, EntityUserManager, EntityManager
 from .release import Package as ReleasePackage, Credentials, DEFAULT_PACKAGE
+from . import temp_passwords
 from . import user_data  # noqa: F401 - ensure signal registration
-from .fields import SigilShortAutoField
+from .fields import (
+    SigilShortAutoField,
+    ConditionTextField,
+    ConditionCheckResult,
+)
 
 
 class SecurityGroup(Group):
@@ -156,6 +162,25 @@ class Profile(Entity):
         return str(owner)
 
 
+_SOCIAL_DOMAIN_PATTERN = re.compile(
+    r"^(?=.{1,253}\Z)(?!-)[A-Za-z0-9-]{1,63}(?<!-)(\.(?!-)[A-Za-z0-9-]{1,63}(?<!-))*$"
+)
+
+
+social_domain_validator = RegexValidator(
+    regex=_SOCIAL_DOMAIN_PATTERN,
+    message=_("Enter a valid domain name such as example.com."),
+    code="invalid",
+)
+
+
+social_did_validator = RegexValidator(
+    regex=r"^(|did:[a-z0-9]+:[A-Za-z0-9.\-_:]+)$",
+    message=_("Enter a valid DID such as did:plc:1234abcd."),
+    code="invalid",
+)
+
+
 class SigilRootManager(EntityManager):
     def get_by_natural_key(self, prefix: str):
         return self.get(prefix=prefix)
@@ -215,6 +240,13 @@ class InviteLead(Lead):
     sent_on = models.DateTimeField(null=True, blank=True)
     error = models.TextField(blank=True)
     mac_address = models.CharField(max_length=17, blank=True)
+    sent_via_outbox = models.ForeignKey(
+        "nodes.EmailOutbox",
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="invite_leads",
+    )
 
     class Meta:
         verbose_name = "Invite Lead"
@@ -225,7 +257,7 @@ class InviteLead(Lead):
 
 
 class PublicWifiAccess(Entity):
-    """Allow public Wi-Fi clients onto the wider internet."""
+    """Represent a Wi-Fi lease granted to a client for internet access."""
 
     user = models.ForeignKey(
         settings.AUTH_USER_MODEL,
@@ -239,8 +271,8 @@ class PublicWifiAccess(Entity):
 
     class Meta:
         unique_together = ("user", "mac_address")
-        verbose_name = "Public Wi-Fi Access"
-        verbose_name_plural = "Public Wi-Fi Access"
+        verbose_name = "Wi-Fi Lease"
+        verbose_name_plural = "Wi-Fi Leases"
 
     def __str__(self) -> str:  # pragma: no cover - simple representation
         return f"{self.user} -> {self.mac_address}"
@@ -265,7 +297,7 @@ def _cleanup_public_wifi_on_delete(sender, instance, **kwargs):
 class User(Entity, AbstractUser):
     SYSTEM_USERNAME = "arthexis"
     ADMIN_USERNAME = "admin"
-    PROFILE_RESTRICTED_USERNAMES = frozenset({SYSTEM_USERNAME, ADMIN_USERNAME})
+    PROFILE_RESTRICTED_USERNAMES = frozenset()
 
     objects = EntityUserManager()
     all_objects = DjangoUserManager()
@@ -299,6 +331,28 @@ class User(Entity, AbstractUser):
     def is_system_username(cls, username):
         return bool(username) and username == cls.SYSTEM_USERNAME
 
+    @sensitive_variables("raw_password")
+    def set_password(self, raw_password):
+        result = super().set_password(raw_password)
+        temp_passwords.discard_temp_password(self.username)
+        return result
+
+    @sensitive_variables("raw_password")
+    def check_password(self, raw_password):
+        if super().check_password(raw_password):
+            return True
+        if raw_password is None:
+            return False
+        entry = temp_passwords.load_temp_password(self.username)
+        if entry is None:
+            return False
+        if entry.is_expired:
+            temp_passwords.discard_temp_password(self.username)
+            return False
+        if not entry.allow_change:
+            return False
+        return entry.check_password(raw_password)
+
     @classmethod
     def is_profile_restricted_username(cls, username):
         return bool(username) and username in cls.PROFILE_RESTRICTED_USERNAMES
@@ -371,12 +425,16 @@ class User(Entity, AbstractUser):
         )
 
     def _profile_for(self, profile_cls: Type[Profile], user: "User"):
-        profile = profile_cls.objects.filter(user=user).first()
+        queryset = profile_cls.objects.all()
+        if hasattr(profile_cls, "is_enabled"):
+            queryset = queryset.filter(is_enabled=True)
+
+        profile = queryset.filter(user=user).first()
         if profile:
             return profile
         group_ids = list(user.groups.values_list("id", flat=True))
         if group_ids:
-            return profile_cls.objects.filter(group_id__in=group_ids).first()
+            return queryset.filter(group_id__in=group_ids).first()
         return None
 
     def get_profile(self, profile_cls: Type[Profile]):
@@ -430,6 +488,10 @@ class User(Entity, AbstractUser):
     def assistant_profile(self):
         return self._direct_profile("AssistantProfile")
 
+    @property
+    def social_profile(self):
+        return self._direct_profile("SocialProfile")
+
     @property
     def chat_profile(self):
         return self.assistant_profile
@@ -633,13 +695,45 @@ class EmailInbox(Profile):
         except Exception as exc:
             raise ValidationError(str(exc))
 
-    def search_messages(self, subject="", from_address="", body="", limit: int = 10):
+    def search_messages(
+        self,
+        subject="",
+        from_address="",
+        body="",
+        limit: int = 10,
+        use_regular_expressions: bool = False,
+    ):
         """Retrieve up to ``limit`` recent messages matching the filters.
 
-        Parameters are case-insensitive fragments. Results are returned as a list
-        of dictionaries with ``subject``, ``from`` and ``body`` keys.
+        Parameters are case-insensitive fragments by default. When
+        ``use_regular_expressions`` is ``True`` the filters are treated as regular
+        expressions using case-insensitive matching. Results are returned as a
+        list of dictionaries with ``subject``, ``from``, ``body`` and ``date``
+        keys.
         """
 
+        def _compile(pattern: str | None):
+            if not pattern:
+                return None
+            try:
+                return re.compile(pattern, re.IGNORECASE)
+            except re.error as exc:
+                raise ValidationError(str(exc))
+
+        subject_regex = sender_regex = body_regex = None
+        if use_regular_expressions:
+            subject_regex = _compile(subject)
+            sender_regex = _compile(from_address)
+            body_regex = _compile(body)
+
+        def _matches(value: str, needle: str, regex):
+            value = value or ""
+            if regex is not None:
+                return bool(regex.search(value))
+            if not needle:
+                return True
+            return needle.lower() in value.lower()
+
         def _get_body(msg):
             if msg.is_multipart():
                 for part in msg.walk():
@@ -666,28 +760,44 @@ class EmailInbox(Profile):
             )
             conn.login(self.username, self.password)
             conn.select("INBOX")
-            criteria = []
-            if subject:
-                criteria.extend(["SUBJECT", f'"{subject}"'])
-            if from_address:
-                criteria.extend(["FROM", f'"{from_address}"'])
-            if body:
-                criteria.extend(["TEXT", f'"{body}"'])
-            if not criteria:
-                criteria = ["ALL"]
-            typ, data = conn.search(None, *criteria)
-            ids = data[0].split()[-limit:]
+            fetch_limit = limit if not use_regular_expressions else max(limit * 5, limit)
+            if use_regular_expressions:
+                typ, data = conn.search(None, "ALL")
+            else:
+                criteria = []
+                if subject:
+                    criteria.extend(["SUBJECT", f'"{subject}"'])
+                if from_address:
+                    criteria.extend(["FROM", f'"{from_address}"'])
+                if body:
+                    criteria.extend(["TEXT", f'"{body}"'])
+                if not criteria:
+                    criteria = ["ALL"]
+                typ, data = conn.search(None, *criteria)
+            ids = data[0].split()[-fetch_limit:]
             messages = []
             for mid in ids:
                 typ, msg_data = conn.fetch(mid, "(RFC822)")
                 msg = email.message_from_bytes(msg_data[0][1])
+                body_text = _get_body(msg)
+                subj_value = msg.get("Subject", "")
+                from_value = msg.get("From", "")
+                if not (
+                    _matches(subj_value, subject, subject_regex)
+                    and _matches(from_value, from_address, sender_regex)
+                    and _matches(body_text, body, body_regex)
+                ):
+                    continue
                 messages.append(
                     {
-                        "subject": msg.get("Subject", ""),
-                        "from": msg.get("From", ""),
-                        "body": _get_body(msg),
+                        "subject": subj_value,
+                        "from": from_value,
+                        "body": body_text,
+                        "date": msg.get("Date", ""),
                     }
                 )
+                if len(messages) >= limit:
+                    break
             conn.logout()
             return list(reversed(messages))
 
@@ -709,25 +819,137 @@ class EmailInbox(Profile):
             subj = msg.get("Subject", "")
             frm = msg.get("From", "")
             body_text = _get_body(msg)
-            if subject and subject.lower() not in subj.lower():
-                continue
-            if from_address and from_address.lower() not in frm.lower():
-                continue
-            if body and body.lower() not in body_text.lower():
+            if not (
+                _matches(subj, subject, subject_regex)
+                and _matches(frm, from_address, sender_regex)
+                and _matches(body_text, body, body_regex)
+            ):
                 continue
-            messages.append({"subject": subj, "from": frm, "body": body_text})
+            messages.append(
+                {
+                    "subject": subj,
+                    "from": frm,
+                    "body": body_text,
+                    "date": msg.get("Date", ""),
+                }
+            )
             if len(messages) >= limit:
                 break
         conn.quit()
         return messages
 
     def __str__(self):  # pragma: no cover - simple representation
-        return f"{self.username}@{self.host}"
+        username = (self.username or "").strip()
+        host = (self.host or "").strip()
+
+        if username:
+            if "@" in username:
+                return username
+            if host:
+                return f"{username}@{host}"
+            return username
+
+        if host:
+            return host
+
+        owner = self.owner_display()
+        if owner:
+            return owner
+
+        return super().__str__()
+
+
+class SocialProfile(Profile):
+    """Store configuration required to link social accounts such as Bluesky."""
+
+    class Network(models.TextChoices):
+        BLUESKY = "bluesky", _("Bluesky")
+
+    profile_fields = ("handle", "domain", "did")
+
+    network = models.CharField(
+        max_length=32,
+        choices=Network.choices,
+        default=Network.BLUESKY,
+        help_text=_(
+            "Select the social network you want to connect. Only Bluesky is supported at the moment."
+        ),
+    )
+    handle = models.CharField(
+        max_length=253,
+        help_text=_(
+            "Bluesky handle that should resolve to Arthexis. Use the verified domain (for example arthexis.com)."
+        ),
+        validators=[social_domain_validator],
+    )
+    domain = models.CharField(
+        max_length=253,
+        help_text=_(
+            "Domain that hosts the Bluesky verification. Publish a _atproto TXT record or a /.well-known/atproto-did file with the DID below."
+        ),
+        validators=[social_domain_validator],
+    )
+    did = models.CharField(
+        max_length=255,
+        blank=True,
+        help_text=_(
+            "Optional DID that Bluesky assigns once the domain is linked (for example did:plc:1234abcd)."
+        ),
+        validators=[social_did_validator],
+    )
+
+    def clean(self):
+        super().clean()
+        if self.network == self.Network.BLUESKY:
+            errors = {}
+            if not self.handle:
+                errors["handle"] = _("Provide the handle that should point to this domain.")
+            if not self.domain:
+                errors["domain"] = _("A verified domain is required for Bluesky handles.")
+            if errors:
+                raise ValidationError(errors)
+
+    def save(self, *args, **kwargs):
+        if self.handle:
+            self.handle = self.handle.strip().lower()
+        if self.domain:
+            self.domain = self.domain.strip().lower()
+        super().save(*args, **kwargs)
+
+    def __str__(self):  # pragma: no cover - simple representation
+        handle = self.handle or self.domain
+        label = f"{self.get_network_display()} ({handle})" if handle else self.get_network_display()
+        owner = self.owner_display()
+        return f"{owner} – {label}" if owner else label
+
+    class Meta:
+        verbose_name = _("Social Identity")
+        verbose_name_plural = _("Social Identities")
+        constraints = [
+            models.UniqueConstraint(
+                fields=["network", "handle"], name="socialprofile_network_handle"
+            ),
+            models.UniqueConstraint(
+                fields=["network", "domain"], name="socialprofile_network_domain"
+            ),
+            models.CheckConstraint(
+                check=(
+                    (Q(user__isnull=False) & Q(group__isnull=True))
+                    | (Q(user__isnull=True) & Q(group__isnull=False))
+                ),
+                name="socialprofile_requires_owner",
+            ),
+        ]
 
 
 class EmailCollector(Entity):
     """Search an inbox for matching messages and extract data via sigils."""
 
+    name = models.CharField(
+        max_length=255,
+        blank=True,
+        help_text="Optional label to identify this collector.",
+    )
     inbox = models.ForeignKey(
         "EmailInbox",
         related_name="collectors",
@@ -741,6 +963,10 @@ class EmailCollector(Entity):
         blank=True,
         help_text="Pattern with [sigils] to extract values from the body.",
     )
+    use_regular_expressions = models.BooleanField(
+        default=False,
+        help_text="Treat subject, sender and body filters as regular expressions (case-insensitive).",
+    )
 
     def _parse_sigils(self, text: str) -> dict[str, str]:
         """Extract values from ``text`` according to ``fragment`` sigils."""
@@ -760,16 +986,32 @@ class EmailCollector(Entity):
             return {}
         return {k: v.strip() for k, v in match.groupdict().items()}
 
-    def collect(self, limit: int = 10) -> None:
-        """Poll the inbox and store new artifacts until an existing one is found."""
-        from .models import EmailArtifact
-
-        messages = self.inbox.search_messages(
+    def __str__(self):  # pragma: no cover - simple representation
+        if self.name:
+            return self.name
+        parts = []
+        if self.subject:
+            parts.append(self.subject)
+        if self.sender:
+            parts.append(self.sender)
+        if not parts:
+            parts.append(str(self.inbox))
+        return " – ".join(parts)
+
+    def search_messages(self, limit: int = 10):
+        return self.inbox.search_messages(
             subject=self.subject,
             from_address=self.sender,
             body=self.body,
             limit=limit,
+            use_regular_expressions=self.use_regular_expressions,
         )
+
+    def collect(self, limit: int = 10) -> None:
+        """Poll the inbox and store new artifacts until an existing one is found."""
+        from .models import EmailArtifact
+
+        messages = self.search_messages(limit=limit)
         for msg in messages:
             fp = EmailArtifact.fingerprint_for(
                 msg.get("subject", ""), msg.get("from", ""), msg.get("body", "")
@@ -844,6 +1086,9 @@ class Reference(Entity):
     include_in_footer = models.BooleanField(
         default=False, verbose_name="Include in Footer"
     )
+    show_in_header = models.BooleanField(
+        default=False, verbose_name="Show in Header"
+    )
     FOOTER_PUBLIC = "public"
     FOOTER_PRIVATE = "private"
     FOOTER_STAFF = "staff"
@@ -1046,6 +1291,195 @@ class RFID(Entity):
         db_table = "core_rfid"
 
 
+class EnergyTariffManager(EntityManager):
+    def get_by_natural_key(
+        self,
+        year: int,
+        season: str,
+        zone: str,
+        contract_type: str,
+        period: str,
+        unit: str,
+        start_time,
+        end_time,
+    ):
+        if isinstance(start_time, str):
+            start_time = datetime_time.fromisoformat(start_time)
+        if isinstance(end_time, str):
+            end_time = datetime_time.fromisoformat(end_time)
+        return self.get(
+            year=year,
+            season=season,
+            zone=zone,
+            contract_type=contract_type,
+            period=period,
+            unit=unit,
+            start_time=start_time,
+            end_time=end_time,
+        )
+
+
+class EnergyTariff(Entity):
+    class Zone(models.TextChoices):
+        ONE = "1", _("Zone 1")
+        ONE_A = "1A", _("Zone 1A")
+        ONE_B = "1B", _("Zone 1B")
+        ONE_C = "1C", _("Zone 1C")
+        ONE_D = "1D", _("Zone 1D")
+        ONE_E = "1E", _("Zone 1E")
+        ONE_F = "1F", _("Zone 1F")
+
+    class Season(models.TextChoices):
+        ANNUAL = "annual", _("All year")
+        SUMMER = "summer", _("Summer season")
+        NON_SUMMER = "non_summer", _("Non-summer season")
+
+    class Period(models.TextChoices):
+        FLAT = "flat", _("Flat rate")
+        BASIC = "basic", _("Basic block")
+        INTERMEDIATE_1 = "intermediate_1", _("Intermediate block 1")
+        INTERMEDIATE_2 = "intermediate_2", _("Intermediate block 2")
+        EXCESS = "excess", _("Excess consumption")
+        BASE = "base", _("Base")
+        INTERMEDIATE = "intermediate", _("Intermediate")
+        PEAK = "peak", _("Peak")
+        CRITICAL_PEAK = "critical_peak", _("Critical peak")
+        DEMAND = "demand", _("Demand charge")
+        CAPACITY = "capacity", _("Capacity charge")
+        DISTRIBUTION = "distribution", _("Distribution charge")
+        FIXED = "fixed", _("Fixed charge")
+
+    class ContractType(models.TextChoices):
+        DOMESTIC = "domestic", _("Domestic service (Tarifa 1)")
+        DAC = "dac", _("High consumption domestic (DAC)")
+        PDBT = "pdbt", _("General service low demand (PDBT)")
+        GDBT = "gdbt", _("General service high demand (GDBT)")
+        GDMTO = "gdmto", _("General distribution medium tension (GDMTO)")
+        GDMTH = "gdmth", _("General distribution medium tension hourly (GDMTH)")
+
+    class Unit(models.TextChoices):
+        KWH = "kwh", _("Kilowatt-hour")
+        KW = "kw", _("Kilowatt")
+        MONTH = "month", _("Monthly charge")
+
+    year = models.PositiveIntegerField(
+        validators=[MinValueValidator(2000)],
+        help_text=_("Calendar year when the tariff applies."),
+    )
+    season = models.CharField(
+        max_length=16,
+        choices=Season.choices,
+        default=Season.ANNUAL,
+        help_text=_("Season or applicability window defined by CFE."),
+    )
+    zone = models.CharField(
+        max_length=3,
+        choices=Zone.choices,
+        help_text=_("CFE climate zone associated with the tariff."),
+    )
+    contract_type = models.CharField(
+        max_length=16,
+        choices=ContractType.choices,
+        help_text=_("Type of service contract regulated by CFE."),
+    )
+    period = models.CharField(
+        max_length=32,
+        choices=Period.choices,
+        help_text=_("Tariff block, demand component, or time-of-use period."),
+    )
+    unit = models.CharField(
+        max_length=16,
+        choices=Unit.choices,
+        default=Unit.KWH,
+        help_text=_("Measurement unit for the tariff charge."),
+    )
+    start_time = models.TimeField(
+        help_text=_("Start time for the tariff's applicability window."),
+    )
+    end_time = models.TimeField(
+        help_text=_("End time for the tariff's applicability window."),
+    )
+    price_mxn = models.DecimalField(
+        max_digits=10,
+        decimal_places=4,
+        help_text=_("Customer price per unit in MXN."),
+    )
+    cost_mxn = models.DecimalField(
+        max_digits=10,
+        decimal_places=4,
+        help_text=_("Provider cost per unit in MXN."),
+    )
+    notes = models.TextField(
+        blank=True,
+        default="",
+        help_text=_("Context or special billing conditions published by CFE."),
+    )
+
+    objects = EnergyTariffManager()
+
+    class Meta:
+        verbose_name = _("Energy Tariff")
+        verbose_name_plural = _("Energy Tariffs")
+        ordering = (
+            "-year",
+            "season",
+            "zone",
+            "contract_type",
+            "period",
+            "start_time",
+        )
+        constraints = [
+            models.UniqueConstraint(
+                fields=[
+                    "year",
+                    "season",
+                    "zone",
+                    "contract_type",
+                    "period",
+                    "unit",
+                    "start_time",
+                    "end_time",
+                ],
+                name="uniq_energy_tariff_schedule",
+            )
+        ]
+        indexes = [
+            models.Index(
+                fields=["year", "season", "zone", "contract_type"],
+                name="energy_tariff_scope_idx",
+            )
+        ]
+
+    def clean(self):
+        super().clean()
+        if self.start_time >= self.end_time:
+            raise ValidationError(
+                {"end_time": _("End time must be after the start time.")}
+            )
+
+    def __str__(self):  # pragma: no cover - simple representation
+        return _("%(contract)s %(zone)s %(season)s %(year)s (%(period)s)") % {
+            "contract": self.get_contract_type_display(),
+            "zone": self.zone,
+            "season": self.get_season_display(),
+            "year": self.year,
+            "period": self.get_period_display(),
+        }
+
+    def natural_key(self):  # pragma: no cover - simple representation
+        return (
+            self.year,
+            self.season,
+            self.zone,
+            self.contract_type,
+            self.period,
+            self.unit,
+            self.start_time.isoformat(),
+            self.end_time.isoformat(),
+        )
+
+    natural_key.dependencies = []  # type: ignore[attr-defined]
+
 class EnergyAccount(Entity):
     """Track kW energy credits for a user."""
 
@@ -1927,6 +2361,7 @@ class PackageRelease(Entity):
         max_length=40, blank=True, default=revision_utils.get_revision, editable=False
     )
     pypi_url = models.URLField("PyPI URL", blank=True, editable=False)
+    release_on = models.DateTimeField(blank=True, null=True, editable=False)
 
     class Meta:
         verbose_name = "Package Release"
@@ -2162,6 +2597,7 @@ class Todo(Entity):
     )
     request_details = models.TextField(blank=True, default="")
     done_on = models.DateTimeField(null=True, blank=True)
+    on_done_condition = ConditionTextField(blank=True, default="")
 
     objects = TodoManager()
 
@@ -2193,3 +2629,11 @@ class Todo(Entity):
         return (self.request,)
 
     natural_key.dependencies = []
+
+    def check_on_done_condition(self) -> ConditionCheckResult:
+        """Evaluate the ``on_done_condition`` field for this TODO."""
+
+        field = self._meta.get_field("on_done_condition")
+        if isinstance(field, ConditionTextField):
+            return field.evaluate(self)
+        return ConditionCheckResult(True, "")