wbcrm 1.56.8__py2.py3-none-any.whl

wbcrm/models/events.py

@@ -0,0 +1,15 @@
+from django.db import models
+
+
+class Event(models.Model):
+    """
+    we store the event notification we received from the webhook in this model to easily debug the sync
+    """
+
+    data = models.JSONField(default=dict, blank=True)
+    result = models.JSONField(default=dict, blank=True)
+    created = models.DateTimeField(auto_now_add=True)
+    updated = models.DateTimeField(auto_now=True)
+
+    def __str__(self) -> str:
+        return str(self.id)

wbcrm/models/groups.py

@@ -0,0 +1,119 @@
+from celery import shared_task
+from django.db import models
+from django.db.models.signals import m2m_changed, pre_delete
+from django.dispatch import receiver
+from django.utils import timezone
+from django.utils.translation import gettext_lazy as _
+from wbcore.contrib.agenda.models import CalendarItem
+from wbcore.contrib.directory.models import Company, Entry, Person
+from wbcore.models import WBModel
+
+from wbcrm.models import Activity
+
+
+class Group(WBModel):
+    title = models.CharField(max_length=255, unique=True, verbose_name=_("Title"))
+    members = models.ManyToManyField("directory.Entry", related_name="groups", verbose_name=_("Members"))
+
+    class Meta:
+        verbose_name = _("Group")
+        verbose_name_plural = _("Groups")
+
+    def __str__(self):
+        return self.title
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcrm:group"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcrm:grouprepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{title}}"
+
+
+@receiver(m2m_changed, sender=Group.members.through)
+def m2m_changed_members(sender, instance, action, pk_set, **kwargs):
+    """
+    M2m changed Group signal: Change participants, companies and entities of future planned activities/calendar items
+    if a group's members get updated
+    """
+    if action == "post_add":
+        add_changed_group_members(instance, pk_set)
+
+    if action == "post_remove":
+        remove_changed_group_members(instance, pk_set)
+
+
+@receiver(pre_delete, sender=Group)
+def pre_delete_group(sender, instance, **kwargs):
+    """
+    Post delete Group signal: Remove members from future planned activities/calendar items if a group was deleted
+    """
+    remove_deleted_groups_members(instance)
+
+
+@shared_task
+def add_changed_group_members(instance, pk_set):
+    for activity in Activity.objects.filter(
+        status=Activity.Status.PLANNED, start__gte=timezone.now(), groups=instance
+    ):
+        item = CalendarItem.all_objects.get(id=activity.id)
+        for member in pk_set:
+            entry = Entry.all_objects.get(id=member)
+            if entry not in item.entities.all():
+                item.entities.add(entry)
+            if entry.is_company:
+                company = Company.all_objects.get(id=entry.id)
+                if company not in activity.companies.all():
+                    activity.companies.add(company)
+            else:
+                person = Person.all_objects.get(id=entry.id)
+                if person not in activity.participants.all():
+                    activity.participants.add(person)
+
+
+@shared_task
+def remove_changed_group_members(instance, pk_set):
+    for activity in Activity.objects.filter(
+        status=Activity.Status.PLANNED, start__gte=timezone.now(), groups=instance
+    ):
+        item = CalendarItem.all_objects.get(id=activity.id)
+        for member in pk_set:
+            entry = Entry.all_objects.get(id=member)
+            if entry in item.entities.all():
+                item.entities.remove(entry)
+            if entry.is_company:
+                company = Company.all_objects.get(id=entry.id)
+                if company in activity.companies.all():
+                    activity.companies.remove(company)
+            else:
+                person = Person.all_objects.get(id=entry.id)
+                if person in activity.participants.all():
+                    activity.participants.remove(person)
+
+
+@shared_task
+def remove_deleted_groups_members(instance):
+    for activity in Activity.objects.filter(
+        status=Activity.Status.PLANNED, start__gte=timezone.now(), groups=instance
+    ):
+        item = CalendarItem.all_objects.get(id=activity.id)
+        for member in instance.members.all():
+            if member in item.entities.all():
+                item.entities.remove(member)
+            if member.is_company:
+                company = Company.all_objects.get(id=member.id)
+                if company in activity.companies.all():
+                    activity.companies.remove(company)
+            else:
+                person = Person.all_objects.get(id=member.id)
+                if person in activity.participants.all():
+                    activity.participants.remove(person)

wbcrm/models/llm/activity_summaries.py

@@ -0,0 +1,41 @@
+from typing import TYPE_CHECKING
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from pydantic import BaseModel, Field
+from wbcore.contrib.ai.llm.config import LLMConfig
+
+if TYPE_CHECKING:
+    from wbcrm.models import Activity  # noqa
+
+
+class ActivityLLMResponseModel(BaseModel):
+    heat: int = Field(..., ge=1, le=4, description="The sentiment heat.")
+    summary: str = Field(..., description="A summary of the activity in English.")
+
+
+def get_query(instance):
+    return {
+        "title": instance.title,
+        "description": instance.description,
+        "period": instance.period,
+        "participants": instance.participants.all(),
+        "companies": instance.companies.all(),
+        "result": instance.result,
+    }
+
+
+analyze_activity = LLMConfig["Activity"](
+    key="analyze",
+    prompt=[
+        SystemMessage(
+            content="You are a manager in a company and there are activities, both internal as well as external, meaning between service providers, clients and ourselves. We want to analyze these activities in regards of their sentiment and summarize them in English. The summary should be a very short bottom-line focussed text."
+        ),
+        HumanMessage(
+            content="title={title}, description={description}, period={period}, participants={participants}, companies={companies}, review={result}"
+        ),
+    ],
+    on_save=True,
+    on_condition=lambda instance: instance.status == "REVIEWED",
+    output_model=ActivityLLMResponseModel,
+    query=get_query,
+)

wbcrm/models/llm/analyze_relationship.py

@@ -0,0 +1,50 @@
+from typing import TYPE_CHECKING
+
+from langchain_core.messages import HumanMessage, SystemMessage
+from pydantic import BaseModel, Field
+from wbcore.contrib.ai.llm.config import LLMConfig
+from wbcrm.models.activities import Activity
+
+if TYPE_CHECKING:
+    from wbcrm.models import Account
+
+
+class AccountRelationshipResponseModel(BaseModel):
+    relationship_status: int = Field(
+        ...,
+        ge=1,
+        le=5,
+        description="Rate the customer relationship status from 1 to 5. 1 being the cold and 5 being the hot.",
+    )
+    relationship_summary: str = Field(
+        ...,
+        description="Briefly summarize the current state of the relationship and recent interactions. Also include any additional information that might be relevant.",
+    )
+    action_plan: str = Field(
+        ..., description="Provide the next recommended actions or steps to engage with the customer."
+    )
+
+
+def _get_query(account: "Account"):
+    details = []
+    if account.owner:
+        for activity in Activity.objects.filter(companies__id__in=[account.owner.id], status="REVIEWED"):
+            details.append((activity.summary, activity.heat, activity.period))
+    return {"title": account.title, "details": details}
+
+
+analyze_relationship = LLMConfig["Account"](
+    key="analyze_relationship",
+    prompt=[
+        SystemMessage(
+            content="Based on the recent interactions/activities, current relationship health, and planned actions with the customer, provide a status score (1 to 5, where 1 is cold and 5 is hot), a summary of the relationship, and recommended next steps for maintaining or improving the relationship. Keep in mind that more information might become available later to refine these insights. Please include all information that is relevant to the relationship in the summary. Regarding the activities/interactions, older interactions are less relevant than recent ones."
+        ),
+        HumanMessage(
+            content="The title of the account: {title} and the list of activities details (tuple of summary, sentiment heat and period): {details}",
+        ),
+    ],
+    on_save=True,
+    on_condition=lambda act: (act.status == act.Status.OPEN) and act.owner is not None and act.is_root_node(),
+    output_model=AccountRelationshipResponseModel,
+    query=_get_query,
+)

wbcrm/models/products.py

@@ -0,0 +1,86 @@
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from slugify import slugify
+from wbcore.models import WBModel
+from wbcore.utils.models import ComplexToStringMixin
+
+
+class ProductCompanyRelationship(models.Model):
+    product = models.ForeignKey(
+        on_delete=models.CASCADE,
+        to="wbcrm.Product",
+        verbose_name=_("Product"),
+        related_name="product_company_relationships",
+    )
+    company = models.ForeignKey(
+        on_delete=models.CASCADE,
+        to="directory.Company",
+        verbose_name=_("Company"),
+        related_name="product_company_relationships",
+    )
+
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(name="unique_company_product_relationship", fields=["product", "company"])
+        ]
+        verbose_name = _("Company-Product Relationship")
+        verbose_name_plural = _("Company-Product Relationships")
+
+    def __str__(self) -> str:
+        return f"{self.product} - {self.company}"
+
+
+class Product(ComplexToStringMixin, WBModel):
+    title = models.CharField(
+        max_length=128,
+        verbose_name=_("Title"),
+    )
+
+    slugify_title = models.CharField(
+        max_length=128,
+        verbose_name="Slugified Title",
+        blank=True,
+        null=True,
+    )
+    is_competitor = models.BooleanField(
+        verbose_name=_("Is Competitor"),
+        default=False,
+        help_text=_("Indicates wether this is a competitor's product"),
+    )
+
+    prospects = models.ManyToManyField(
+        "directory.Company",
+        related_name="interested_products",
+        blank=True,
+        verbose_name=_("Prospects"),
+        help_text=_("The list of prospects"),
+        through="wbcrm.ProductCompanyRelationship",
+        through_fields=("product", "company"),
+    )
+
+    def __str__(self) -> str:
+        return self.title
+
+    def compute_str(self) -> str:
+        return _("{} (Competitor)").format(self.title) if self.is_competitor else self.title
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbcrm:product"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbcrm:productrepresentation-list"
+
+    class Meta:
+        verbose_name = _("Product")
+        verbose_name_plural = _("Products")
+        unique_together = [["slugify_title", "is_competitor"]]
+
+    def save(self, *args, **kwargs):
+        self.slugify_title = slugify(self.title, separator=" ")
+        super().save(*args, **kwargs)

wbcrm/models/recurrence.py

@@ -0,0 +1,280 @@
+from datetime import datetime, timedelta
+
+import pytz
+from dateutil import rrule
+from django.core.validators import MaxValueValidator, MinValueValidator
+from django.db import models
+from django.db.models import Q
+from django.utils.translation import gettext_lazy as _
+from psycopg.types.range import TimestamptzRange
+from wbcore.contrib.agenda.models import CalendarItem
+from wbcore.utils.rrules import convert_rrulestr_to_dict
+
+from wbcrm.preferences import (
+    get_maximum_allowed_recurrent_date,
+    get_recurrence_maximum_count,
+)
+
+
+class Recurrence(CalendarItem):
+    class ReoccuranceChoice(models.TextChoices):
+        NEVER = "NEVER", _("Never")
+        BUSINESS_DAILY = "RRULE:FREQ=DAILY;INTERVAL=1;WKST=MO;BYDAY=MO,TU,WE,TH,FR", _("Business Daily")
+        DAILY = "RRULE:FREQ=DAILY", _("Daily")
+        WEEKLY = "RRULE:FREQ=WEEKLY", _("Weekly")
+        BIWEEKLY = "RRULE:FREQ=WEEKLY;INTERVAL=2", _("Bi-Weekly")
+        MONTHLY = "RRULE:FREQ=MONTHLY", _("Monthly")
+        QUARTERLY = "RRULE:FREQ=MONTHLY;INTERVAL=3", _("Quarterly")
+        YEARLY = "RRULE:FREQ=YEARLY", _("Annually")
+
+    parent_occurrence = models.ForeignKey(
+        to="self",
+        related_name="child_activities",
+        null=True,
+        blank=True,
+        verbose_name=_("Parent Activity"),
+        on_delete=models.deletion.DO_NOTHING,
+    )
+    propagate_for_all_children = models.BooleanField(
+        default=False,
+        verbose_name=_("Propagate for all following activities?"),
+        help_text=_("If this is checked, changes will be propagated to the following activities."),
+    )
+    exclude_from_propagation = models.BooleanField(
+        default=False,
+        verbose_name=_("Exclude occurrence from propagation?"),
+        help_text=_("If this is checked, changes will not be propagated on this activity."),
+    )
+    recurrence_end = models.DateField(
+        verbose_name=_("Date"),
+        null=True,
+        blank=True,
+        help_text=_(
+            "Specifies until when an event is to be repeated. Is mutually exclusive with the Recurrence Count."
+        ),
+    )
+    recurrence_count = models.IntegerField(
+        validators=[MinValueValidator(1), MaxValueValidator(365)],
+        null=True,
+        blank=True,
+        verbose_name=_("Count"),
+        help_text=_(
+            "Specifies how often an activity should be repeated excluding the original activity. Is mutually exclusive with the end date. Limited to a maximum of 365 recurrences."
+        ),
+    )
+    repeat_choice = models.CharField(
+        max_length=56,
+        default=ReoccuranceChoice.NEVER,
+        choices=ReoccuranceChoice.choices,
+        verbose_name=_("Recurrence Frequency"),
+        help_text=_("Repeat activity at the specified frequency"),
+    )
+
+    class Meta:
+        abstract = True
+
+    @property
+    def is_recurrent(self):
+        return self.repeat_choice != Recurrence.ReoccuranceChoice.NEVER
+
+    @property
+    def is_root(self):
+        return self.is_recurrent and not self.parent_occurrence
+
+    @property
+    def is_leaf(self):
+        return self.is_recurrent and not self.next_occurrence
+
+    @property
+    def next_occurrence(self):
+        if self.is_recurrent:
+            parent_occurrence = self if self.is_root else self.parent_occurrence
+            if qs := parent_occurrence.child_activities.filter(
+                is_active=True, period__startswith__gt=self.period.lower
+            ):
+                return qs.earliest("period__startswith")
+
+    @property
+    def previous_occurrence(self):
+        if self.is_recurrent and not self.is_root:
+            if qs := self.parent_occurrence.child_activities.filter(
+                is_active=True, period__startswith__lt=self.period.lower
+            ):
+                return qs.latest("period__startswith")
+            else:
+                return self.parent_occurrence
+        # Else, it is a pivot and therefore, no previous occurrence should exist
+
+    def save(self, *args, **kwargs):
+        if not self.recurrence_end:
+            self.recurrence_end = get_maximum_allowed_recurrent_date()
+        if self.does_recurrence_need_cancellation():
+            self.cancel_recurrence()
+        super().save(*args, **kwargs)
+
+    def delete(self, **kwargs):
+        if self.propagate_for_all_children:
+            self.forward_deletion()
+        elif self.is_root and (next_occurrence := self.next_occurrence):
+            next_occurrence.claim_parent_hood()
+        super().delete(**kwargs)
+
+    def _get_occurrence_start_datetimes(self, include_self: bool = False) -> list:
+        """
+        Returns a list with datetime values based on the recurrence options of an activity.
+
+        :return:    list with datetime values
+        """
+        if self.is_recurrent:
+            max_allowed_date = get_maximum_allowed_recurrent_date()
+            max_allowed_count = get_recurrence_maximum_count()
+            occurrence_count = min(
+                self.recurrence_count + 1 if self.recurrence_count else max_allowed_count, max_allowed_count
+            )
+            end_date = min(
+                self.recurrence_end + timedelta(days=1) if self.recurrence_end else max_allowed_date, max_allowed_date
+            )
+            end_date_time = datetime(end_date.year, end_date.month, end_date.day).astimezone(pytz.utc)
+            rule_dict = convert_rrulestr_to_dict(
+                self.repeat_choice, dtstart=self.period.lower, count=occurrence_count, until=end_date_time
+            )
+
+            start_datetimes = list(rrule.rrule(**rule_dict))
+            if not include_self:
+                start_date = self.period.lower.replace(microsecond=0)
+                if self.period.lower in start_datetimes:
+                    start_datetimes.remove(self.period.lower)
+                elif start_date in start_datetimes:
+                    start_datetimes.remove(start_date)
+            return start_datetimes
+
+    def _create_recurrence_child(self, *args):
+        """
+        Return a new child object based on self (parent/root)
+        """
+        raise NotImplementedError()
+
+    def get_recurrent_valid_children(self):
+        """
+        Return a valid queryset representing the recurrent children
+        """
+        return self.child_activities.filter(exclude_from_propagation=False).order_by("period__startswith")
+
+    def get_recurrent_invalid_children(self):
+        valid = self.get_recurrent_valid_children().values_list("id", flat=True)
+        return self.child_activities.all().exclude(id__in=valid).order_by("period__startswith")
+
+    def _handle_recurrence_m2m_forwarding(self, child):
+        """
+        Call this when m2m data needs to be forward from the parent (self) to the passed child
+
+        Args:
+            child: Child to get the m2m data from
+        """
+        pass
+
+    def does_recurrence_need_cancellation(self) -> bool:
+        return False
+
+    def cancel_recurrence(self):
+        """
+        keep the link to the root but exclude the occurrence from the list of valid children's to maintain, propagations will no longer be applied to this activity
+
+        its a transition method, save needs to be called
+        """
+        self.exclude_from_propagation = True
+
+    def claim_parent_hood(self):
+        if self.is_recurrent and not self.is_root:
+            new_batch = self._meta.model.objects.filter(
+                Q(parent_occurrence=self.parent_occurrence) & Q(period__startswith__gt=self.period.lower)
+            ).exclude(id=self.id)
+            if new_batch.exists():
+                new_batch.update(parent_occurrence=self)
+            self._meta.model.objects.filter(id=self.id).update(parent_occurrence=None)
+
+    def generate_occurrences(self, allow_reclaiming_root: bool = True):
+        """
+        Creation of the occurrences
+        Existing occurrences whose start date is part of the list of occurrences dates obtained from the recurrence pattern are excluded
+        Those not in the list are deleted
+        """
+        if self.is_recurrent:
+            if not self.is_root and allow_reclaiming_root:
+                self.claim_parent_hood()
+                self.refresh_from_db()
+            if self.is_root:
+                if old_occurrences_dict := {occ.period.lower: occ.id for occ in self.child_activities.all()}:
+                    occurrence_dates = set(self._get_occurrence_start_datetimes())
+                    old_occurrences_dates = set(old_occurrences_dict.keys())
+                    new_occurrence_dates = occurrence_dates.difference(old_occurrences_dates)
+                    if diff_inv := old_occurrences_dates.difference(occurrence_dates):
+                        self.forward_deletion(child_ids=[old_occurrences_dict[x] for x in diff_inv])
+                else:
+                    new_occurrence_dates = self._get_occurrence_start_datetimes()
+                for start_datetime in new_occurrence_dates:
+                    child = self._create_recurrence_child(start_datetime)
+                    self._handle_recurrence_m2m_forwarding(child)
+        return self.get_recurrent_valid_children()
+
+    def forward_change(
+        self,
+        allow_reclaiming_root: bool = True,
+        fields_to_forward: tuple[str, ...] = (
+            "online_meeting",
+            "visibility",
+            "conference_room",
+            "title",
+            "description",
+            "type",
+            "importance",
+            "reminder_choice",
+            "location",
+            "location_longitude",
+            "location_latitude",
+            "assigned_to",
+        ),
+        period_time_changed: bool = False,
+    ):
+        """
+        Forward the changes to the following occurrences
+        param: fields_to_forward: allows you to specify the fields to update
+               allow_reclaiming_root: if True we split the occurrences and this occurrence becomes the parent of the following occurrences
+               period_time_changed: boolean field to know if we need to update the period time or not
+        """
+        if self.is_recurrent and self.propagate_for_all_children:
+            if not self.is_root and allow_reclaiming_root:
+                self.claim_parent_hood()
+                self.refresh_from_db()
+            if self.is_root:
+                for child in self.get_recurrent_valid_children().order_by("period__startswith"):
+                    for field in fields_to_forward:
+                        setattr(child, field, getattr(self, field))
+                    if period_time_changed:
+                        tz = child.period.lower.tzinfo
+                        start_datetime = datetime.combine(
+                            child.period.lower.date(), self.period.lower.time()
+                        ).astimezone(tz)
+                        child.period = TimestamptzRange(start_datetime, (start_datetime + self.duration))
+                    child.propagate_for_all_children = False
+                    child.save()
+                    self._handle_recurrence_m2m_forwarding(child)
+            self._meta.model.objects.filter(id=self.id).update(propagate_for_all_children=False)
+
+    def forward_deletion(self, child_ids: tuple["str", ...] = ()):
+        if self.is_recurrent:
+            if self.is_root:
+                occurrences = self.get_recurrent_valid_children()
+            else:
+                occurrences = self.parent_occurrence.get_recurrent_valid_children().filter(
+                    period__startswith__gt=self.period.lower
+                )
+            if child_ids:
+                occurrences = occurrences.filter(id__in=child_ids)
+            if self.propagate_for_all_children:
+                # We don't call delete but update to is_active=False in order to silently delete the child activities without trggering the signals
+                occurrences.update(is_active=False)
+                self._meta.model.objects.filter(id=self.id).update(propagate_for_all_children=False)
+            else:
+                for occurrence in occurrences:
+                    occurrence.delete()

wbcrm/preferences.py

@@ -0,0 +1,13 @@
+from datetime import date, timedelta
+
+from dynamic_preferences.registries import global_preferences_registry
+
+
+def get_maximum_allowed_recurrent_date():
+    global_preferences = global_preferences_registry.manager()
+    return date.today() + timedelta(days=global_preferences["wbcrm__recurrence_maximum_allowed_days"])
+
+
+def get_recurrence_maximum_count():
+    global_preferences = global_preferences_registry.manager()
+    return global_preferences["wbcrm__recurrence_maximum_count"]