fix: hubspot attribution issues (#5560)

Co-authored-by: Matthew Elwell <matthew.elwell@flagsmith.com>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

api/custom_auth/views.py

@@ -29,6 +29,9 @@
 from custom_auth.mfa.trench.serializers import CodeLoginSerializer
 from custom_auth.mfa.trench.utils import user_token_generator
 from custom_auth.serializers import CustomUserDelete
+from integrations.lead_tracking.hubspot.services import (
+    register_hubspot_tracker,
+)
 from users.constants import DEFAULT_DELETE_ORPHAN_ORGANISATIONS_VALUE
 from users.models import FFAdminUser
 from users.serializers import PatchOnboardingSerializer
@@ -125,6 +128,7 @@ def get_throttles(self):  # type: ignore[no-untyped-def]
 
     def create(self, request: Request, *args: Any, **kwargs: Any) -> Response:
         response = super().create(request, *args, **kwargs)
+        register_hubspot_tracker(request, user=self.user)
         if settings.COOKIE_AUTH_ENABLED:
             authorise_response(self.user, response)
         return response  # type: ignore[no-any-return]

api/integrations/lead_tracking/hubspot/client.py

@@ -1,10 +1,11 @@
 import json
 import logging
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 import hubspot  # type: ignore[import-untyped]
 import requests
 from django.conf import settings
+from hubspot.crm.associations.v4 import AssociationSpec  # type: ignore[import-untyped]
 from hubspot.crm.companies import (  # type: ignore[import-untyped]
     PublicObjectSearchRequest,
     SimplePublicObjectInput,
@@ -20,7 +21,9 @@
     HUBSPOT_PORTAL_ID,
     HUBSPOT_ROOT_FORM_URL,
 )
-from users.models import FFAdminUser
+
+if TYPE_CHECKING:
+    from users.models import FFAdminUser
 
 logger = logging.getLogger(__name__)
 
@@ -30,7 +33,7 @@ def __init__(self, client: hubspot.Client = None) -> None:
         self.access_token = settings.HUBSPOT_ACCESS_TOKEN
         self.client = client or hubspot.Client.create(access_token=self.access_token)
 
-    def get_contact(self, user: FFAdminUser) -> None | dict[str, Any]:
+    def get_contact(self, user: "FFAdminUser") -> None | dict[str, Any]:
         public_object_id = BatchReadInputSimplePublicObjectId(
             id_property="email",
             inputs=[{"id": user.email}],
@@ -54,7 +57,7 @@ def get_contact(self, user: FFAdminUser) -> None | dict[str, Any]:
         return results[0]  # type: ignore[no-any-return]
 
     def create_lead_form(
-        self, user: FFAdminUser, hubspot_cookie: str
+        self, user: "FFAdminUser", hubspot_cookie: str | None = None
     ) -> dict[str, Any]:
         logger.info(
             f"Creating Hubspot lead form for user {user.email} with hubspot cookie {hubspot_cookie}"
@@ -69,11 +72,13 @@ def create_lead_form(
             {"objectTypeId": "0-1", "name": "lastname", "value": user.last_name},
         ]
 
-        context = {
-            "hutk": hubspot_cookie,
-            "pageUri": "www.flagsmith.com",
-            "pageName": "Homepage",
-        }
+        context = {}
+        if hubspot_cookie:
+            context = {
+                "hutk": hubspot_cookie,
+                "pageUri": "www.flagsmith.com",
+                "pageName": "Homepage",
+            }
 
         legal = {
             "consent": {
@@ -103,37 +108,20 @@ def create_lead_form(
             )
         return response.json()  # type: ignore[no-any-return]
 
-    def create_contact(
-        self, user: FFAdminUser, hubspot_company_id: str
-    ) -> dict[str, Any]:
-        properties = {
-            "email": user.email,
-            "firstname": user.first_name,
-            "lastname": user.last_name,
-            "hs_marketable_status": user.marketing_consent_given,
-        }
-        return self._create_contact(properties, hubspot_company_id)
-
-    def _create_contact(
-        self, properties: dict[str, Any], hubspot_company_id: str
-    ) -> dict[str, str]:
-        response = self.client.crm.contacts.basic_api.create(
-            simple_public_object_input_for_create=SimplePublicObjectInputForCreate(
-                properties=properties,
-                associations=[
-                    {
-                        "types": [
-                            {
-                                "associationCategory": "HUBSPOT_DEFINED",
-                                "associationTypeId": 1,
-                            }
-                        ],
-                        "to": {"id": hubspot_company_id},
-                    }
-                ],
+    def associate_contact_to_company(self, contact_id: str, company_id: str) -> None:
+        association_spec = [
+            AssociationSpec(
+                association_category="HUBSPOT_DEFINED", association_type_id=1
             )
+        ]
+
+        self.client.crm.associations.v4.basic_api.create(
+            object_type="contacts",
+            object_id=contact_id,
+            to_object_type="companies",
+            to_object_id=company_id,
+            association_spec=association_spec,
         )
-        return response.to_dict()  # type: ignore[no-any-return]
 
     def create_self_hosted_contact(
         self, email: str, first_name: str, last_name: str, hubspot_company_id: str
@@ -144,7 +132,28 @@ def create_self_hosted_contact(
             "lastname": last_name,
             "api_lead_source": HUBSPOT_API_LEAD_SOURCE_SELF_HOSTED,
         }
-        self._create_contact(properties, hubspot_company_id)
+
+        create_params = {
+            "simple_public_object_input_for_create": SimplePublicObjectInputForCreate(
+                properties=properties,
+            )
+        }
+
+        if hubspot_company_id:
+            create_params["simple_public_object_input_for_create"].associations = [
+                {
+                    "types": [
+                        {
+                            "associationCategory": "HUBSPOT_DEFINED",
+                            "associationTypeId": 1,
+                        }
+                    ],
+                    "to": {"id": hubspot_company_id},
+                }
+            ]
+
+        response = self.client.crm.contacts.basic_api.create(**create_params)
+        return response.to_dict()  # type: ignore[no-any-return]
 
     def get_company_by_domain(self, domain: str) -> dict[str, Any] | None:
         """
@@ -201,11 +210,17 @@ def create_company(
         return response.to_dict()  # type: ignore[no-any-return]
 
     def update_company(
-        self, active_subscription: str, hubspot_company_id: str
+        self,
+        hubspot_company_id: str,
+        name: str | None = None,
+        active_subscription: str | None = None,
     ) -> dict[str, Any]:
-        properties = {
-            "active_subscription": active_subscription,
-        }
+        properties = {}
+        if name is not None:
+            properties["name"] = name
+        if active_subscription is not None:
+            properties["active_subscription"] = active_subscription
+
         simple_public_object_input = SimplePublicObjectInput(properties=properties)
 
         response = self.client.crm.companies.basic_api.update(

api/integrations/lead_tracking/hubspot/lead_tracker.py

@@ -1,4 +1,6 @@
 import logging
+import time
+from typing import Any
 
 from django.conf import settings
 
@@ -44,88 +46,147 @@ def should_track(user: FFAdminUser) -> bool:
 
         return True
 
-    def create_lead(self, user: FFAdminUser, organisation: Organisation = None) -> None:  # type: ignore[assignment]
-        contact_data = self.client.get_contact(user)
+    def update_company_active_subscription(
+        self, subscription: Subscription
+    ) -> dict[str, Any] | None:
+        if not subscription.plan:
+            return None
 
-        if contact_data:
-            # The user is already present in the system as a lead
-            # for an existing organisation, so return early.
-            return
+        organisation = subscription.organisation
 
-        hubspot_id = self.get_or_create_organisation_hubspot_id(user, organisation)
+        # Check if we're missing the associated hubspot id.
+        if not getattr(organisation, "hubspot_organisation", None):
+            return None
+
+        response: dict[str, Any] | None = self.client.update_company(
+            active_subscription=subscription.plan,
+            hubspot_company_id=organisation.hubspot_organisation.hubspot_id,
+        )
 
-        response = self.client.create_contact(user, hubspot_id)
+        return response
 
+    def create_user_hubspot_contact(self, user: FFAdminUser) -> str | None:
+        tracker = HubspotTracker.objects.filter(user=user).first()
+        tracker_cookie = tracker.hubspot_cookie if tracker else None
+        self.client.create_lead_form(user=user, hubspot_cookie=tracker_cookie)
+
+        # Create lead form creates a contact asynchronously in hubspot but does not return the contact id
+        # We need to get the contact id separately and retry 3 times
+        contact = self._get_new_contact_with_retry(user, max_retries=3)
+        if not contact:
+            # Hubspot creates contact asynchronously
+            # If not available on the spot, following steps will sync database with Hubspot
+            logger.error(f"Failed to create contact for user {user.email}")
+            return None
+
+        hubspot_contact_id = contact.get("id")
         HubspotLead.objects.update_or_create(
-            user=user, defaults={"hubspot_id": response["id"]}
+            user=user, defaults={"hubspot_id": hubspot_contact_id}
         )
 
-        if tracker := HubspotTracker.objects.filter(user=user).first():
-            self.client.create_lead_form(
-                user=user, hubspot_cookie=tracker.hubspot_cookie
-            )
+        return hubspot_contact_id
+
+    def create_lead(self, user: FFAdminUser, organisation: Organisation) -> None:
+        hubspot_contact_id = self._get_or_create_user_hubspot_id(user)
+        if not hubspot_contact_id:
+            return
+        hubspot_org_id = self._get_or_create_organisation_hubspot_id(user, organisation)
+        if not hubspot_org_id:
+            return
+
+        self.client.associate_contact_to_company(
+            contact_id=hubspot_contact_id,
+            company_id=hubspot_org_id,
+        )
 
-    def get_or_create_organisation_hubspot_id(
+    def _get_new_contact_with_retry(
+        self, user: FFAdminUser, max_retries: int = 3
+    ) -> dict[str, Any] | None:
+        for retry in range(max_retries + 1):
+            contact = self.client.get_contact(user)
+            if contact:
+                return contact  # type: ignore[no-any-return]
+            time.sleep(0.5 * retry)  # 3 retries: 0.5s, 1s, 1.5s
+        return None
+
+    def _get_or_create_user_hubspot_id(self, user: FFAdminUser) -> str | None:
+        hubspot_lead = HubspotLead.objects.filter(user=user).first()
+        if hubspot_lead:
+            hubspot_contact_id: str | None = hubspot_lead.hubspot_id
+        else:
+            # Fallback to sync database with Hubspot if contact hubspot_id was not saved
+            contact_data = self.client.get_contact(user)
+            if contact_data:
+                hubspot_contact_id = contact_data["id"]
+                HubspotLead.objects.update_or_create(
+                    user=user, defaults={"hubspot_id": hubspot_contact_id}
+                )
+            else:
+                logger.error(
+                    f"Fallback creating contact for user {user.email} when associating with organisation"
+                )
+                hubspot_contact_id = self.create_user_hubspot_contact(user)
+
+        return hubspot_contact_id
+
+    def _get_or_create_organisation_hubspot_id(
         self,
         user: FFAdminUser,
-        organisation: Organisation = None,  # type: ignore[assignment]
-    ) -> str:
+        organisation: Organisation,
+    ) -> str | None:
         """
         Return the Hubspot API's id for an organisation.
         """
-        if organisation and getattr(organisation, "hubspot_organisation", None):
+        if getattr(organisation, "hubspot_organisation", None):
             return organisation.hubspot_organisation.hubspot_id
 
         if user.email_domain in settings.HUBSPOT_IGNORE_ORGANISATION_DOMAINS:
-            domain = None
-        else:
-            domain = user.email_domain
+            return None
 
-        if organisation:
-            response = self.client.create_company(
+        domain = user.email_domain
+        company_kwargs = {"domain": domain}
+        company_kwargs["name"] = organisation.name
+        company_kwargs["organisation_id"] = organisation.id
+        company_kwargs["active_subscription"] = organisation.subscription.plan
+
+        # As Hubspot creates/associates companies based on contact domain
+        # we need to get the hubspot id when this user creates the company for the first time
+        # and update the company name
+        company = self._get_or_create_hubspot_company(**company_kwargs)
+        org_hubspot_id: str = company["id"]
+
+        properties = company.get("properties", {})
+        existing_name = properties.get("name")
+        if existing_name != organisation.name:
+            self.client.update_company(
                 name=organisation.name,
-                active_subscription=organisation.subscription.plan,
-                organisation_id=organisation.id,
-                domain=domain,
+                hubspot_company_id=org_hubspot_id,
             )
 
-            # Store the organisation data in the database since we are
-            # unable to look them up via a unique identifier.
-            HubspotOrganisation.objects.create(
-                organisation=organisation,
-                hubspot_id=response["id"],
-            )
-        else:
-            response = self._get_or_create_company_by_domain(domain)  # type: ignore[arg-type]
-
-        return response["id"]  # type: ignore[no-any-return]
-
-    def update_company_active_subscription(
-        self, subscription: Subscription
-    ) -> dict | None:  # type: ignore[type-arg]
-        if not subscription.plan:
-            return  # type: ignore[return-value]
-
-        organisation = subscription.organisation
-
-        # Check if we're missing the associated hubspot id.
-        if not getattr(organisation, "hubspot_organisation", None):
-            return  # type: ignore[return-value]
-
-        response = self.client.update_company(
-            active_subscription=subscription.plan,
-            hubspot_company_id=organisation.hubspot_organisation.hubspot_id,
+        # Store the organisation data in the database since we are
+        # unable to look them up via a unique identifier.
+        HubspotOrganisation.objects.create(
+            organisation=organisation,
+            hubspot_id=org_hubspot_id,
         )
 
-        return response  # type: ignore[no-any-return]
+        return org_hubspot_id
 
-    def _get_or_create_company_by_domain(self, domain: str) -> dict:  # type: ignore[type-arg]
+    def _get_or_create_hubspot_company(
+        self,
+        domain: str,
+        organisation_id: int,
+        name: str,
+        active_subscription: str | None = None,
+    ) -> dict[str, Any]:
         company = self.client.get_company_by_domain(domain)
         if not company:
-            # Since we don't know the company's name, we pass the domain as
-            # both the name and the domain. This can then be manually
-            # updated in Hubspot if needed.
-            company = self.client.create_company(name=domain, domain=domain)
+            company = self.client.create_company(
+                name=name,
+                domain=domain,
+                organisation_id=organisation_id,
+                active_subscription=active_subscription,
+            )
 
         return company  # type: ignore[no-any-return]