user_assignment_from_api.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import looker_sdk # if unavailable, pip install looker_sdk"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Important note about Authorization\n",
    "\n",
    "The following line is authorizing you to use the API on our instance, but it requires you to have a looker.ini file with the following:\n",
    "\n",
    "```\n",
    "[Looker]\n",
    "base_url = \"https://[COMPANY_NAME].looker.com:19999\"\n",
    "client_id = \"YOUR_CLIENT_ID\"\n",
    "client_secret = \"YOUR_CLIENT_SECRET\"\n",
    "```\n",
    "\n",
    "If you don't have a `client_id` and `client_secret`, you will need\n",
    "to get your API3 keys from your Looker Admin. If you are a Looker Admin,\n",
    "head to Admin > Users and edit a user. You'll be able to edit / create API3\n",
    "keys from this menu. \n",
    "\n",
    "**Keep your API3 Secret SAFE and do not put any code on GitHub that has your client secret exposed.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read the text above for more info on how to initiate your API session\n",
    "admin_sdk = looker_sdk.init31()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Removes all users in a list of user_ids from a single group\n",
    "\n",
    "def remove_users_from_group(admin_sdk, user_id_list, group_id):\n",
    "    # Iterate through user_id_list\n",
    "    for user_id in user_id_list:\n",
    "      # Delete the user from the group\n",
    "      admin_sdk.delete_group_user(group_id, user_id)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adds all users in a list of user_ids to a single group\n",
    "\n",
    "def add_users_to_group(admin_sdk, user_id_list, group_id):\n",
    "    # Iterate through user_id_list\n",
    "    for user_id in user_id_list:\n",
    "        # Generate the body to pass through the API call\n",
    "        body = {\n",
    "            'user_id': user_id\n",
    "        }\n",
    "        # Add the user to the group\n",
    "        admin_sdk.add_group_user(group_id, body)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Create new groups from a base name\n",
    "This function pairs well with the new role function below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_new_groups(admin_sdk, group_base_name, nest_groups:bool = True):\n",
    "    '''\n",
    "    Creates new Viewer, Explorer, and Developer groups with a base name prefix.\n",
    "    \n",
    "        nest_groups -   Nests Developer inside Explorer, and Explorer inside Viewer.\n",
    "                        This ensures that Developers will inherit Explorer and Viewer permissions\n",
    "                        and Explorers will inherit viewer permissions.\n",
    "        \n",
    "        returns a list of the new names to be passed into create_new_role function\n",
    "    '''\n",
    "    new_group_names = []\n",
    "\n",
    "    # The order here is important when we start nesting groups a few lines below\n",
    "    group_suffixes = ['Viewer', 'Explorer', 'Developer']\n",
    "\n",
    "    for group_suffix in group_suffixes:\n",
    "        full_group_name = f'{group_base_name} {group_suffix}'\n",
    "        new_group_names.append(full_group_name)\n",
    "        body = {\n",
    "            'name': full_group_name\n",
    "        }\n",
    "        new_group = admin_sdk.create_group(body)\n",
    "\n",
    "        if nest_groups:\n",
    "\n",
    "            # Store the value of the viewer group for nesting later\n",
    "            if group_suffix == \"Viewer\":\n",
    "                viewer_group_id = new_group.id\n",
    "\n",
    "            # All explorers should be viewers, so nest explorer group\n",
    "            # inside of viewer group\n",
    "            elif group_suffix == \"Explorer\":\n",
    "                explorer_group_id = new_group.id\n",
    "\n",
    "                # Prepare body to add explorer group to viewer group\n",
    "                explorer_body = {\n",
    "                    \"group_id\": explorer_group_id\n",
    "                }\n",
    "                admin_sdk.add_group_group(viewer_group_id, explorer_body)\n",
    "            \n",
    "            # All Developers should be explorers and viewers, so nest\n",
    "            # Inside of explorer group, which will be nested inside viewer group\n",
    "            else:\n",
    "                developer_group_id = new_group.id\n",
    "\n",
    "                # Prepare body to add developer group to explorer group\n",
    "                developer_body = {\n",
    "                    \"group_id\": developer_group_id\n",
    "                }\n",
    "                admin_sdk.add_group_group(explorer_group_id, developer_body)\n",
    "    return new_group_names\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_new_role(admin_sdk, new_role_name, new_role_groups: list):\n",
    "    '''\n",
    "    Make sure groups are defined first! This will auto \n",
    "    assign groups for you if they exist already\n",
    "\n",
    "    new_role_groups: list - should be a list of names of \n",
    "    groups to add to the new role\n",
    "    '''\n",
    "\n",
    "    # This will only work if you have set up roles for 'Viewer', 'Explorer', 'and 'Developer'\n",
    "    base_role_name = new_role_name.split()[-1]\n",
    "    # Search for 'Viewer', 'Explorer', or 'Developer'\n",
    "    base_role = admin_sdk.search_roles(name=base_role_name)\n",
    "    # Get the permission_set_id from the base_role object\n",
    "    base_permission_set_id = base_role[0].permission_set.id\n",
    "    # Get the model_set_id from the base role object\n",
    "    base_model_set_id = base_role[0].model_set.id\n",
    "\n",
    "    # This requires an existing permission set and model set\n",
    "    # You can define a new permission set and model set by using the\n",
    "    # permission_set: {} and model_set: {} params\n",
    "    # See the API Explorer in your Looker instance for more info\n",
    "    body = {\n",
    "        \"name\": new_role_name,\n",
    "        \"permission_set_id\": base_permission_set_id,\n",
    "        \"model_set_id\": base_model_set_id,\n",
    "    }\n",
    "\n",
    "    # Create the new role\n",
    "    new_role = admin_sdk.create_role(body)\n",
    "\n",
    "    # Get the id of the role we just created\n",
    "    new_role_id = new_role.id\n",
    "\n",
    "    # Get the group ids currently associated with the role\n",
    "    current_role_group_ids = [group.id for group in admin_sdk.role_groups(new_role_id)]\n",
    "\n",
    "    # Get the group ids for the new role groups\n",
    "    new_role_group_ids = [new_role_group.id for new_role_group in admin_sdk.all_groups() if new_role_group.name in new_role_groups]\n",
    "\n",
    "    # Add the new_role_group to the current_role_group_ids\n",
    "    updated_role_group_ids = current_role_group_ids + new_role_group_ids\n",
    "\n",
    "    admin_sdk.set_role_groups(new_role_id, updated_role_group_ids)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating full group names to pass through the create_new_role() function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Test Marketing Viewer', 'Test Marketing Explorer', 'Test Marketing Developer']\n"
     ]
    }
   ],
   "source": [
    "group_base_name = 'Test Marketing'\n",
    "nest_groups = True\n",
    "\n",
    "'''\n",
    "The lines below will create new groups and connect them to new roles\n",
    "with basic model set and permission sets. Uncomment to make a live \n",
    "API call and add the new groups and roles\n",
    "'''\n",
    "# The role name and group name are the same, in our case\n",
    "# new_group_list = create_new_groups(admin_sdk, group_base_name, nest_groups)\n",
    "# print(new_group_list)\n",
    "# for group_name in new_group_list:\n",
    "#   create_new_role(admin_sdk, group_name, group_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## CODE EXAMPLES: Getting user info from a csv and using it in the API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Store csv contents in pandas dataframe\n",
    "# We have a \"Team\" and \"Display_Name\" field in this csv\n",
    "\n",
    "csv_path = '..\\looker_users.csv' # Update this with your csv path\n",
    "df = pd.read_csv(csv_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Storing team value for searching\n",
    "team = 'Marketing'\n",
    "\n",
    "# Store people from a specific team\n",
    "user_list = df[df['Team'] == team].sort_values('Display_Name')\n",
    "\n",
    "# Get a list of user ids to pass through functions\n",
    "user_id_list = list(user_list['id'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Obtaining group ids via a search with wildcards\n",
    "group_id = admin_sdk.search_groups(name='Marketing')[0].id"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding users to group with the id above. You can hard code in the ID\n",
    "# If you find it via the Admin > Groups page in Looker\n",
    "\n",
    "# Line left commented because we don't want to accidentally add users\n",
    "# add_users_to_group(admin_sdk, user_id_list, group_id)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "63fd5069d213b44bf678585dea6b12cceca9941eaf7f819626cde1f2670de90d"
  },
  "kernelspec": {
   "display_name": "Python 3.9.2 64-bit",
   "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.2"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}