rdxz2-utill 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

utill/my_mb.py

@@ -1,384 +1,378 @@
-
-import csv
-import json
-import os
-import requests
-
-from loguru import logger
-
 from .my_const import HttpMethod
-from .my_csv import write as csv_write
-from .my_dict import AutoPopulatingDict
 from .my_env import MB_FILENAME
-
-
-class UsersNotFoundException(Exception):
-    def __init__(self, username: list[str]):
-        self.message = f'User(s) {username} not exists'
-        super().__init__(self.message)
-
-
-def _decode_collection_location_to_group(collections_dict: dict, location: str):
-    return ' > '.join(map(lambda x: collections_dict[x], map(int, location.strip('/').split('/'))))
-
-
-def _translate_user_group_ids(user: dict) -> set:
-    return set(user['group_ids']) - {1}  # Exclude 'All Users' group
+from loguru import logger
+import json
 
 
 class MB:
     def __init__(self, config_source: str = MB_FILENAME) -> None:
-        config = json.loads(open(config_source, 'r').read())
-
-        self.base_url = config['base_url']
-        self.api_key = config['api_key']
-
-        self._is_user_initialized = False
-        self._is_group_initialized = False
-        self._is_collection_initialized = False
-
-        self.dict__question_id__question = AutoPopulatingDict(self._fetch_question_by_id)
-        self.dict__question_url__question = AutoPopulatingDict(self._fetch_question_by_url)
-        self.dict__dashboard_id__dashboard = AutoPopulatingDict(self._fetch_dashboard_by_id)
-        self.dict__collection_id__collection = AutoPopulatingDict(self._fetch_collection_by_id)
-
-        logger.info(f'✅ Initialized {self.base_url}')
-
-    # <<----- START: Util
-
-    def send_request(self, method: HttpMethod, endpoint: str, json_data: dict = None) -> requests.Response:
-        url = f'{self.base_url}/{endpoint}'
-        logger.debug(f'🚗 [{method}] {endpoint}')
-
-        headers = {
-            'x-api-key': self.api_key
-        }
-
-        if method == HttpMethod.GET:
-            response = requests.get(url, headers=headers)
-        elif method == HttpMethod.POST:
-            response = requests.post(url, headers=headers, json=json_data)
-        elif method == HttpMethod.PUT:
-            response = requests.put(url, headers=headers, json=json_data)
-        elif method == HttpMethod.DELETE:
-            response = requests.delete(url, headers=headers, json=json_data)
-        else:
-            raise ValueError(f'HTTP method {method} not recognized!')
-
-        if not (200 <= response.status_code < 300):
-            raise Exception(f'HTTP error {response.status_code}: {response.text}')
-
-        return response
+        config = json.loads(open(config_source, "r").read())
+
+        self.base_url = config["base_url"]
+        self.api_key = config["api_key"]
+
+        logger.info(f"✅ Initialized {self.base_url}")
+
+    # region Utility
+
+    def http_request(self, method, url, **kwargs):
+        url = f"{self.base_url}/{url.lstrip('/')}"
+        kwargs.setdefault("headers", {"x-api-key": self.api_key})
+        return super().http_request(method, url, **kwargs)
+
+    def decode_collection_location_to_group(self, location: str):
+        group_names = []
+        for collection_id in location.strip("/").split("/"):
+            # if collection_id not in self.known_collections_by_id:
+            #     collection = self.get_collection(collection_id)
+            #     self.known_collections_by_id[collection_id] = collection
+
+            # group_names.append(self.known_collections_by_id[collection_id]['name'])
+
+            collection = self.get_collection(collection_id)
+            group_names.append(collection["name"])
+
+        return " > ".join(group_names)
+
+    @staticmethod
+    def translate_user_group_ids(user: dict) -> set:
+        return set(user["group_ids"]) - {1}  # Exclude 'All Users' group
+
+    # endregion
+
+    # region User
+
+    def get_all_users(self, all=False) -> list[dict]:
+        params = {}
+        if all:
+            params["status"] = "all"
+        return self.http_request(
+            HttpMethod.GET,
+            "api/user",
+            params=params,
+        ).json()["data"]
+
+    def get_user(
+        self,
+        user_id: int,
+    ) -> dict:
+        return self.http_request(HttpMethod.GET, f"api/user/{user_id}").json()
+
+    def create_user(
+        self, first_name: str, last_name: str, email: str, group_ids: list[int] = [1]
+    ) -> dict:
+        new_user = self.http_request(
+            HttpMethod.POST,
+            "api/user",
+            json={
+                "first_name": first_name,
+                "last_name": last_name,
+                "email": email,
+                "user_group_memberships": [{"id": group_id} for group_id in group_ids],
+            },
+        ).json()
+        logger.debug(f"✅ User [{new_user['id']}] {email} created")
+        return new_user
 
-    def reinit(self):
-        self.__init__()
+    def disable_user(self, id: str):
+        self.http_request(HttpMethod.DELETE, f"api/user/{id}")
+        logger.debug(f"✅ User {id} disabled")
 
-    # END: Util ----->>
+    def enable_user(self, id: str):
+        self.http_request(HttpMethod.PUT, f"api/user/{id}/reactivate")
+        logger.debug(f"✅ User {id} enabled")
 
-    # <<----- START: User
+    def reset_password(self, email: str):
+        self.http_request(
+            HttpMethod.POST, "api/session/forgot_password", json={"email": email}
+        )
+        logger.debug(f"✅ User {email} password has been reset")
 
-    def _init_all_users(self):
-        if not self._is_user_initialized:
-            logger.debug('🕐 Initialize user data')
-            response_json = self.send_request(HttpMethod.GET, 'api/user').json()['data']
-            self._dict__user_id__user = {x['id']: x for x in response_json}
-            self._dict__user_email__user = {x['email']: x for x in response_json}
-            self._is_user_initialized = True
+    # endregion
 
-    @property
-    def dict__user_id__user(self) -> dict:
-        self._init_all_users()
-        return self._dict__user_id__user
+    # region Group
 
-    @property
-    def dict__user_email__user(self) -> dict:
-        self._init_all_users()
-        return self._dict__user_email__user
+    def get_all_groups(self) -> list[dict]:
+        return self.http_request(HttpMethod.GET, "api/permissions/group").json()
 
-    def make_sure_all_email_exists(self, emails: list[str]):
-        not_exists = []
-        for email in emails:
-            try:
-                self.dict__user_email__user[email]
-            except KeyError:
-                not_exists.append(email)
-
-        if not_exists:
-            raise UsersNotFoundException(not_exists)
-
-    def create_user(self, first_name: str, last_name: str, email: str, group_ids: list):
-        self.send_request(HttpMethod.POST, 'api/user', {
-            'first_name': first_name,
-            'last_name': last_name,
-            'email': email,
-            'user_group_memberships': group_ids,
-        }).json()
-        self._is_user_initialized = False
-        logger.info(f'✅ Create user {email}')
-
-    def deactivate_user_by_email(self, email: str):
-        try:
-            user = self.dict__user_email__user[email]
-        except KeyError as e:
-            raise UsersNotFoundException([email])
-
-        self.send_request(HttpMethod.DELETE, f'api/user/{user["id"]}')
-        del self.dict__user_email__user[email]
-        logger.info(f'✅ Deactivate user [{user["id"]}] {email}')
-
-    def reset_password_by_email(self, email: str):
-        try:
-            self.dict__user_email__user[email]
-        except KeyError as e:
-            raise UsersNotFoundException([email])
-        self.send_request(HttpMethod.POST, 'api/session/forgot_password', {'email': email})
-        logger.info(f'✅ Reset password {email}')
-
-    # END: User ----->>
-
-    # <<----- START: Group
-
-    def _init_all_groups(self):
-        if not self._is_group_initialized:
-            logger.debug('🕐 Initialize group data')
-            response_json = self.send_request(HttpMethod.GET, 'api/permissions/group').json()
-            self._dict__group_id__group = {x['id']: x for x in response_json}
-            self._dict__group_name__group = {x['name']: x for x in response_json}
-            self._is_group_initialized = True
-
-    @property
-    def dict__group_id__group(self) -> dict:
-        self._init_all_groups()
-        return self._dict__group_id__group
-
-    @property
-    def dict__group_name__group(self) -> dict:
-        self._init_all_groups()
-        return self._dict__group_name__group
+    def get_group(self, group_id: int) -> dict:
+        return self.http_request(
+            HttpMethod.GET, f"api/permissions/group/{group_id}"
+        ).json()
 
     def create_group(self, group_name: str):
-        self.send_request(HttpMethod.POST, 'api/permissions/group', {
-            'name': group_name,
-        })
-        self._is_group_initialized = False
-        logger.info(f'✅ Create group {group_name}')
-
-    def delete_group(self, group_name: str):
-        self.send_request(HttpMethod.DELETE, f'api/permissions/group/{self.dict__group_name__group[group_name]["id"]}')
-        self._is_group_initialized = False
-        logger.info(f'✅ Delete group {group_name}')
-
-    # END: Group ----->>
-
-    # <<----- START: Permission
+        self.http_request(
+            HttpMethod.POST,
+            "api/permissions/group",
+            json={
+                "name": group_name,
+            },
+        )
+        logger.debug(f"✅ Group {group_name} created")
 
-    def grant_user_id_to_group_by_id(self, user_id: int, group_id: int) -> None:
-        self.send_request(HttpMethod.POST, 'api/permissions/membership', {
-            'group_id': group_id,
-            'user_id': user_id,
-        })
+    def delete_group(self, id: str):
+        self.http_request(
+            HttpMethod.DELETE,
+            f"api/permissions/group/{id}",
+        )
+        logger.debug(f"✅ Group {id} deleted")
 
-        # Update locally
-        self.dict__user_id__user[user_id]['group_ids'].append(group_id)
-        self.dict__user_email__user[self.dict__user_id__user[user_id]['email']]['group_ids'].append(group_id)
+    # endregion
 
-        logger.info(f'✅ Grant user \'{self.dict__user_id__user[user_id]["email"]}\' to group \'{self.dict__group_id__group[group_id]["name"]}\'')
+    # region Question / card
 
-    def mirror_user_permission_by_email(self, source_email: str, target_email: str) -> None:
-        source_user = self.dict__user_email__user[source_email]
-        target_user = self.dict__user_email__user[target_email]
+    def get_question(self, id: int) -> dict:
+        return self.http_request(HttpMethod.GET, f"api/card/{id}").json()
 
-        source_user_group_ids = _translate_user_group_ids(source_user)
-        target_user_group_ids = _translate_user_group_ids(target_user)
+    def change_question_connection(self, id: int, connection_id: int) -> None:
+        dataset_query = self.get_question(id)["dataset_query"]
+        if dataset_query["database"] == connection_id:
+            logger.warning(f"⚠️ Question {id} already using connection {connection_id}")
+            return
+        dataset_query["database"] = connection_id
+        self.http_request(
+            HttpMethod.PUT,
+            f"api/card/{id}",
+            json={"dataset_query": dataset_query},
+        )
+        logger.debug(f"✅ Question {id} connection changed to {connection_id}")
+
+    def archive_question(self, id: int) -> None:
+        self.http_request(HttpMethod.PUT, f"api/card/{id}", json={"archived": True})
+        logger.debug(f"✅ Question {id} archived")
+
+    # endregion
+
+    # region Dashboard
+
+    def get_dashboard(self, id: int) -> None:
+        return self.http_request(HttpMethod.GET, f"api/dashboard/{id}").json()
+
+    # endregion
+
+    # region Collection
+
+    # def get_all_collections(self, collection_id: int) -> dict:
+    #     logger.debug("🕐 Initialize collection data")
+    #     response_json = [
+    #         x for x in self.http_request(HttpMethod.GET, "api/collection").json()[1:]
+    #     ]  # Exclude root collection
+    #     self.dict__collection_id__collection_name = {
+    #         x["id"]: x["name"] for x in response_json
+    #     }
+    #     self.dict__collection_id__collection = {
+    #         x["id"]: {
+    #             **x,
+    #             "group_name": (
+    #                 " > ".join(
+    #                     [
+    #                         self.decode_collection_location_to_group(
+    #                             self.dict__collection_id__collection_name,
+    #                             x["location"],
+    #                         ),
+    #                         x["name"],
+    #                     ]
+    #                 )
+    #                 if x["location"] != "/"
+    #                 else x["name"]
+    #             ),
+    #         }
+    #         for x in response_json
+    #         if x["personal_owner_id"] is None
+    #     }
+
+    #     if collection_id in self.dict__collection_id__collection:
+    #         return self.dict__collection_id__collection[collection_id]
+    #     else:
+    #         return self.http_request(
+    #             HttpMethod.GET, f"api/collection/{collection_id}"
+    #         ).json()
+
+    def get_collection(self, id: int) -> dict:
+        return self.http_request(HttpMethod.GET, f"api/collection/{id}").json()
+
+    # endregion
+
+    # region Permission
+
+    def grant_user_to_group(self, user_id: int, group_id: int) -> None:
+        self.http_request(
+            HttpMethod.POST,
+            "api/permissions/membership",
+            json={
+                "group_id": group_id,
+                "user_id": user_id,
+                "is_group_manager": False,
+            },
+        )
+        logger.debug(f"✅ Granted user {user_id} to group {group_id}")
 
-        to_be_granted_group_ids = source_user_group_ids - target_user_group_ids
-        existing_group_ids = source_user_group_ids - to_be_granted_group_ids
-        if existing_group_ids:
-            pass
-        for group_id in to_be_granted_group_ids:
-            self.grant_user_id_to_group_by_id(target_user['id'], group_id)
+    def grant_group_to_collection(self, group_id: int, collection_id: int):
+        group_id = str(group_id)
+        collection_id = str(collection_id)
 
-    def grant_group_id_to_collection_by_id(self, group_id: int, collection_id: int):
         # Get latest revision
-        graph = self.send_request(HttpMethod.GET, 'api/collection/graph').json()
+        graph = self.http_request(HttpMethod.GET, "api/collection/graph").json()
         logger.debug(f'Latest revision: {graph["revision"]}')
 
-        group_id_str = str(group_id)
-        collection_id_str = str(collection_id)
-
-        # Test group existence
-        try:
-            self.dict__group_id__group[group_id]
-        except KeyError as e:
-            logger.error(f'Group ID {group_id} not exists')
-            raise e
-
-        # Test collection existence
-        try:
-            self.dict__collection_id__collection[collection_id]
-        except KeyError as e:
-            logger.error(f'Collection ID {collection_id} not exists')
-            raise e
-
-        if graph['groups'][group_id_str][collection_id_str] != 'none':
-            logger.warning(f'Group {self.dict__group_id__group[group_id]["name"]} already has permission {graph["groups"][group_id_str][collection_id_str]} to collection {self.dict__collection_id__collection[collection_id]["name"]}')
-            return
-        graph['groups'][group_id_str][collection_id_str] = 'read'
-
-        self.send_request(HttpMethod.PUT, 'api/collection/graph', {
-            'revision': graph['revision'],
-            'groups': {
-                group_id_str: {
-                    collection_id_str: 'read'
-                }
+        # Update revision grpah
+        self.http_request(
+            HttpMethod.PUT,
+            "api/collection/graph",
+            json={
+                "revision": graph["revision"],
+                "groups": {group_id: {collection_id: "read"}},
             },
-        })
-
-        logger.info(f'✅ Grant group \'{self.dict__group_id__group[group_id]["name"]}\' to collection \'{self.dict__collection_id__collection[collection_id]["name"]}\'')
-
-    def grant_user_email_to_dashboard_by_url(self, email: str, dashboard_url: str):
-        # Get user
-        user = self.dict__user_email__user[email]
-        user_group_ids = _translate_user_group_ids(user)
-
-        # Get dashboard
-        dashboard_id = int(dashboard_url.split(f'{self.base_url}/dashboard/')[1].split('-')[0])
-        dashboard = self.dict__dashboard_id__dashboard[dashboard_id]
-
-        # Get collection
-        collection_id = dashboard['collection_id']
-        collection = self.dict__collection_id__collection[collection_id]
-
-        # Get collection's group
-        try:
-            group = self.dict__group_name__group[collection['group_name']]
-        except KeyError:
-            # Create group if not exists
-            self.create_group(collection['group_name'])
-            group = self.dict__group_name__group[collection['group_name']]
-
-            # Grant group to collection
-            self.grant_group_id_to_collection_by_id(group['id'], collection_id)
-
-        # Skip if user already in group
-        if group['id'] in user_group_ids:
-            logger.warning(f'{dashboard_url}: User {email} already in group {group["name"]}')
-            return
-
-        # Grant
-        self.grant_user_id_to_group_by_id(user['id'], group['id'])
-
-    def grant_user_email_to_collection_by_url(self, email: str, collection_url: str):
-        # Get user
-        user = self.dict__user_email__user[email]
-        user_group_ids = _translate_user_group_ids(user)
-
-        # Get collection
-        collection_id = int(collection_url.split(f'{self.base_url}/collection/')[1].split('-')[0])
-        collection = self.dict__collection_id__collection[collection_id]
-
-        # Get collection's group
-        try:
-            group = self.dict__group_name__group[collection['group_name']]
-        except KeyError:
-            # Create group if not exists
-            self.create_group(collection['group_name'])
-            group = self.dict__group_name__group[collection['group_name']]
-
-            # Grant group to collection
-            self.grant_group_id_to_collection_by_id(group['id'], collection_id)
-
-        # Skip if user already in group
-        if group['id'] in user_group_ids:
-            logger.warning(f'{collection_url}: User {email} already in group {group["name"]}')
-            return
-
-        # Grant
-        self.grant_user_id_to_group_by_id(user['id'], group['id'])
-
-    def grant_user_email_to_question_by_url(self, email: str, question_url: str):
-        # Get user
-        user = self.dict__user_email__user[email]
-        user_group_ids = _translate_user_group_ids(user)
-
-        # Get question
-        question = self.dict__question_url__question[question_url]
-
-        # Get question's collection
-        collection_id = question['collection_id']
-        collection = self.dict__collection_id__collection[question['collection_id']]
-
-        # Get collection's group
-        try:
-            group = self.dict__group_name__group[collection['group_name']]
-        except KeyError:
-            # Create group if not exists
-            self.create_group(collection['group_name'])
-            group = self.dict__group_name__group[collection['group_name']]
-
-            # Grant group to collection
-            self.grant_group_id_to_collection_by_id(group['id'], collection_id)
-
-        # Skip if user already in group
-        if group['id'] in user_group_ids:
-            logger.warning(f'{question_url}: User {email} already in group {group["name"]}')
-            return
-
-        # Grant
-        self.grant_user_id_to_group_by_id(user['id'], group['id'])
-
-    # END: Permission ----->>
-
-    # <<----- START: Collection
-
-    def _fetch_collection_by_id(self, collection_id: int) -> dict:
-        if not self._is_collection_initialized:
-            logger.debug('🕐 Initialize collection data')
-            response_json = [x for x in self.send_request(HttpMethod.GET, 'api/collection').json()[1:]]  # Exclude root collection
-            self.dict__collection_id__collection_name = {x['id']: x['name'] for x in response_json}
-            self.dict__collection_id__collection = {x['id']: {
-                **x,
-                'group_name': ' > '.join([_decode_collection_location_to_group(self.dict__collection_id__collection_name, x['location']), x['name']]) if x['location'] != '/' else x['name']
-            } for x in response_json if x['personal_owner_id'] is None}
-            self._is_collection_initialized = True
-
-            if collection_id in self.dict__collection_id__collection:
-                return self.dict__collection_id__collection[collection_id]
+        )
+        logger.debug(f"✅ Granted group {group_id} to collection {collection_id}")
+
+    def mirror_permission(self, src_user_id: str, dst_user_id: str) -> None:
+        src_user = self.get_user(src_user_id)
+        dst_user = self.get_user(dst_user_id)
+
+        src_user_group_ids = src_user["group_ids"]
+        dst_user_group_ids = dst_user["group_ids"]
+        group_ids_to_grant = list(set(src_user_group_ids) - set(dst_user_group_ids))
+        for group_id_to_grant in group_ids_to_grant:
+            self.grant_user_to_group(dst_user_id, group_id_to_grant)
+
+    # endregion
+
+    # region Other utilities
+
+    @staticmethod
+    def get_object_info_from_url(url: str) -> tuple[str, int]:
+        # Get information for this object
+        logger.info(f"Getting Metabase object information from {url}")
+        url = (
+            str(url).removeprefix("http://").removeprefix("https://")
+        )  # https://somesite/question/1234-xxx-yyy
+        _, object_type, object_id = url.split(
+            "/", 3
+        )  # somesite/question/1234-xxx-yyy
+        object_id = int(object_id.split("-", 1)[0])  # 1234-xxx-yyy
+
+        return object_type, object_id
+
+    # endregion
+
+    # region Final function
+
+    def grant_metabase_access(
+        self,
+        metabase_url: str,
+        emails: list[str],
+        create_user_if_not_exists: bool = False,
+    ):
+        all_users_by_email = {
+            user["email"]: user for user in self.get_all_users(all=True)
+        }
+        all_groups_by_name = {x["name"]: x for x in self.get_all_groups()}
+
+        # Get information for this object
+        logger.info("Getting Metabase object information")
+        object_type, object_id = self.get_object_info_from_url(metabase_url)
+        collection_id: int | None = None
+        collection_location: str | None = None
+        match (object_type):
+            case "question":
+                question = self.get_question(object_id)
+                collection_id = int(question["collection"]["id"])
+                collection_location = question["collection"]["location"] + str(
+                    question["collection"]["id"]
+                )
+            case "dashboard":
+                dashboard = self.get_dashboard(object_id)
+                collection_id = int(dashboard["collection"]["id"])
+                collection_location = dashboard["collection"]["location"] + str(
+                    dashboard["collection"]["id"]
+                )
+            case "collection":
+                collection = self.get_collection(object_id)
+                collection_id = object_id
+                collection_location = collection["location"] + str(
+                    collection["collection"]["id"]
+                )
+            case _:
+                raise ValueError(
+                    f"Unknown object type {object_type} from {metabase_url}"
+                )
+        logger.info(
+            f'Object found: type "{object_type}", ID {object_id}, collection ID {collection_id}'
+        )
+
+        # Get group info that this collection should be granted to
+        logger.info(f"Getting group information for the object: {collection_location}")
+        group_name = self.decode_collection_location_to_group(collection_location)
+        if group_name not in all_groups_by_name:
+            # If group not exists, create it and immediately grant readonly access to the collectiond
+            self.create_group(group_name)
+            all_groups_by_name = {x["name"]: x for x in self.get_all_groups()}
+            group_id = int(all_groups_by_name[group_name]["id"])
+            self.grant_group_to_collection(group_id, collection_id)
         else:
-            return self.send_request(HttpMethod.GET, f'api/collection/{collection_id}').json()
-
-    # END: Collection ----->>
-
-    # <<----- START: Dashboard
-
-    def _fetch_dashboard_by_id(self, dashboard_id: int) -> dict:
-        return self.send_request(HttpMethod.GET, f'api/dashboard/{dashboard_id}').json()
-
-    # END: Dashboard ----->>
-
-    # <<----- START: Question
-
-    def _fetch_question_by_id(self, question_id: int) -> dict:
-        return self.send_request(HttpMethod.GET, f'api/card/{question_id}').json()
-
-    def _fetch_question_by_url(self, question_url: str) -> dict:
-        question_id = int(question_url.split(f'{self.base_url}/question/')[1].split('-')[0])
-        return self._fetch_question_by_id(question_id)
-
-    def download_question_as_csv(self, card_id: int, dst_filename: str = None):
-        dst_filename = os.path.expanduser(dst_filename)
-        response = self.send_request(HttpMethod.POST, f'api/card/{card_id}/query/csv')
-        content_decoded = response.content.decode()
-        csvreader = csv.reader(content_decoded.splitlines(), delimiter=',')
-        data = list(csvreader)
-
-        csv_write(dst_filename, data)
-
-    def archive_question_by_url(self, question_url: str) -> None:
-        question_id = int(question_url.split(f'{self.base_url}/question/')[1].split('-')[0])
-        self.send_request(HttpMethod.PUT, f'api/card/{question_id}', {
-            'archived': True
-        })
-        logger.info(f'✅ Archive question {question_url}')
-
-    # END: Question ----->>
+            group_id = int(all_groups_by_name[group_name]["id"])
+        logger.info(f"Group found: [{group_id}] {group_name}")
+
+        # Get user informations, create if not exists
+        logger.info(f"Getting information from {len(emails)} users")
+        users = set()
+        created_users = 0
+        not_found_emails = []
+        for email in emails:
+            if email not in all_users_by_email:
+                if create_user_if_not_exists:
+                    logger.info(f"Creating user {email}")
+                    email_name, email_domain = email.split("@", 1)
+                    self.create_user(
+                        first_name=email_name,
+                        last_name=email_domain,
+                        email=email,
+                        group_ids=[1],  # Add to 'All Users' group
+                    )
+                    # all_users_by_email = {
+                    #     user["email"]: user for user in self.get_all_users(all=True)
+                    # }
+                    created_users += 1
+                else:
+                    not_found_emails.append(email)
+        if not_found_emails:
+            raise ValueError(f"Users not found: {', '.join(not_found_emails)}")
+
+        # Re-fetch all users if there are new users created
+        if created_users:
+            logger.info("Users created, re-fetching all users")
+            all_users_by_email = {
+                user["email"]: user for user in self.get_all_users(all=True)
+            }
+
+        # Grant access
+        logger.info(
+            f"Granting access to group [{group_id}] {group_name} for {len(emails)} users"
+        )
+        for email in emails:
+            user = all_users_by_email[email]
+            if (
+                not user["is_active"]
+            ) and create_user_if_not_exists:  # Reactivate user if disabled
+                logger.info(f"Reactivating user {user['id']}")
+                self.enable_user(user["id"])
+
+            user_id = int(user["id"])
+            user_email = user["email"]
+            if group_id in user["group_ids"]:
+                # Skip if user already in the group because it will cause 500 error on Metabase later (it tries to insert the permissions to its DB and got duplicate key error)
+                logger.info(f"User {user_id} already in group {group_id}, skipping")
+                continue
+            users.add((user_id, user_email))
+        logger.info(
+            f"Users to be granted: {', '.join([f'[{user_id}] {user_email}' for user_id, user_email in users])}"
+        )
+
+        # Assign all user to the group
+        for user_id, user_email in users:
+            logger.info(f"Assigning user {user_id} to group {group_id}")
+            self.grant_user_to_group(user_id, group_id)
+        logger.info("All users assigned to the group")
+
+    # endregion