<!doctype html>
<html lang="en-GB" dir="ltr" class="docs-wrapper docs-doc-page docs-version-v0.16 plugin-docs plugin-id-default docs-doc-id-Configuration/TeamConfiguration">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<meta name="generator" content="Docusaurus v2.0.0-rc.1">
<link rel="alternate" type="application/rss+xml" href="/blog/rss.xml" title="Apache DevLake - Open-Source Dev Data Platform for Productivity RSS Feed">
<link rel="alternate" type="application/atom+xml" href="/blog/atom.xml" title="Apache DevLake - Open-Source Dev Data Platform for Productivity Atom Feed">

<link rel="preconnect" href="https://www.google-analytics.com">
<link rel="preconnect" href="https://www.googletagmanager.com">
<script async src="https://www.googletagmanager.com/gtag/js?id=G-PKZLL38MQG"></script>
<script>function gtag(){dataLayer.push(arguments)}window.dataLayer=window.dataLayer||[],gtag("js",new Date),gtag("config","G-PKZLL38MQG",{anonymize_ip:!0})</script>







<script id="runllm-widget-script" type="module" src="https://cdn.jsdelivr.net/npm/@runllm/search-widget@stable/dist/run-llm-search-widget.es.js" runllm-server-address="https://api.runllm.com" runllm-assistant-id="157" runllm-position="BOTTOM_RIGHT" runllm-keyboard-shortcut="Mod+j" version="stable" runllm-preset="docusaurus" runllm-slack-community-url="https://join.slack.com/t/devlake-io/shared_invite/zt-20envwfbk-JUTZ4z9jSeRnrvNhBFLg9w" runllm-name="Apache DevLake" runllm-theme-color="#005EEC" async></script><title data-rh="true">Team Configuration | Apache DevLake - Open-Source Dev Data Platform for Productivity</title><meta data-rh="true" name="twitter:card" content="summary_large_image"><meta data-rh="true" property="og:url" content="https://devlake.apache.org/docs/v0.16/Configuration/TeamConfiguration"><meta data-rh="true" name="docusaurus_locale" content="en"><meta data-rh="true" name="docsearch:language" content="en"><meta data-rh="true" name="keywords" content="Engineering Productivity, Open-Source Engineering, Open-Source Integration Tools, Data Integrates Platform, Open-Source Dev Platform, Open-Source Data Integrates, DevOps Tools Integrates, Open-Source DevOps Tools"><meta data-rh="true" name="Content-Security-Policy" content="frame-src &#x27;self&#x27; https://www.google.com/recaptcha/ https://www.google.com/;"><meta data-rh="true" name="docusaurus_version" content="v0.16"><meta data-rh="true" name="docusaurus_tag" content="docs-default-v0.16"><meta data-rh="true" name="docsearch:version" content="v0.16"><meta data-rh="true" name="docsearch:docusaurus_tag" content="docs-default-v0.16"><meta data-rh="true" property="og:title" content="Team Configuration | Apache DevLake - Open-Source Dev Data Platform for Productivity"><meta data-rh="true" name="description" content="Team Configuration
"><meta data-rh="true" property="og:description" content="Team Configuration
"><link data-rh="true" rel="icon" href="/img/logo.svg"><link data-rh="true" rel="canonical" href="https://devlake.apache.org/docs/v0.16/Configuration/TeamConfiguration"><link data-rh="true" rel="alternate" href="https://devlake.apache.org/docs/v0.16/Configuration/TeamConfiguration" hreflang="en-GB"><link data-rh="true" rel="alternate" href="https://devlake.apache.org/zh/docs/v0.16/Configuration/TeamConfiguration" hreflang="zh"><link data-rh="true" rel="alternate" href="https://devlake.apache.org/docs/v0.16/Configuration/TeamConfiguration" hreflang="x-default"><link rel="stylesheet" href="/assets/css/styles.ddc6bf33.css">
<link rel="preload" href="/assets/js/runtime~main.027efac3.js" as="script">
<link rel="preload" href="/assets/js/main.0ab36cb3.js" as="script">
</head>
<body class="navigation-with-keyboard">
<script>!function(){function t(t){document.documentElement.setAttribute("data-theme",t)}var e=function(){var t=null;try{t=localStorage.getItem("theme")}catch(t){}return t}();t(null!==e?e:"light")}()</script><div id="__docusaurus">
<div role="region"><a href="#" class="skipToContent_fXgn">Skip to main content</a></div><nav class="navbar navbar--fixed-top"><div class="navbar__inner"><div class="navbar__items"><button aria-label="Navigation bar toggle" class="navbar__toggle clean-btn" type="button" tabindex="0"><svg width="30" height="30" viewBox="0 0 30 30" aria-hidden="true"><path stroke="currentColor" stroke-linecap="round" stroke-miterlimit="10" stroke-width="2" d="M4 7h22M4 15h22M4 23h22"></path></svg></button><a class="navbar__brand" href="/"><div class="navbar__logo"><img src="/img/logo.svg" alt="apache devlake" class="themedImage_ToTc themedImage--light_HNdA"><img src="/img/logo.svg" alt="apache devlake" class="themedImage_ToTc themedImage--dark_i4oU"></div><b class="navbar__title text--truncate">Apache DevLake</b></a></div><div class="navbar__items navbar__items--right"><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">Docs</a><ul class="dropdown__menu"><li><a class="dropdown__link" href="/docs/Overview/Introduction">Next</a></li><li><a class="dropdown__link" href="/docs/v1.0/Overview/Introduction">v1.0 (Beta)</a></li><li><a class="dropdown__link" href="/docs/v0.21/Overview/Introduction">v0.21 (Stable)</a></li><li><a class="dropdown__link" href="/docs/v0.20/Overview/Introduction">v0.20</a></li><li><a class="dropdown__link" href="/docs/v0.19/Overview/Introduction">v0.19</a></li><li><a class="dropdown__link" href="/docs/v0.18/Overview/Introduction">v0.18</a></li><li><a class="dropdown__link" href="/docs/v0.17/Overview/Introduction">v0.17</a></li><li><a class="dropdown__link" href="/docs/v0.16/Overview/Introduction">v0.16</a></li><li><a class="dropdown__link" href="/docs/v0.15/Overview/Introduction">v0.15</a></li></ul></div><a class="navbar__item navbar__link" href="/livedemo/EngineeringLeads/DORA">Use Cases</a><a class="navbar__item navbar__link" href="/community/">Community</a><a class="navbar__item navbar__link" href="/team">Team</a><a class="navbar__item navbar__link" href="/blogOverview">Blog</a><a href="https://github.com/apache/incubator-devlake" target="_blank" rel="noopener noreferrer" class="navbar__item navbar__link">GitHub</a><a class="navbar__item navbar__link" href="/download">Download</a><div class="navbar__item dropdown dropdown--hoverable dropdown--right"><a href="#" aria-haspopup="true" aria-expanded="false" role="button" class="navbar__link">ASF</a><ul class="dropdown__menu"><li><a href="https://www.apache.org/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Foundation</a></li><li><a href="https://www.apache.org/licenses/" target="_blank" rel="noopener noreferrer" class="dropdown__link">License</a></li><li><a href="https://www.apache.org/events/current-event" target="_blank" rel="noopener noreferrer" class="dropdown__link">Events</a></li><li><a href="https://www.apache.org/security/" target="_blank" rel="noopener noreferrer" class="dropdown__link">Security</a></li><li><a href="https://privacy.apache.org/policies/privacy-policy-public.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Privacy</a></li><li><a href="https://www.apache.org/foundation/sponsorship.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Sponsorship</a></li><li><a href="https://www.apache.org/foundation/thanks.html" target="_blank" rel="noopener noreferrer" class="dropdown__link">Thanks</a></li></ul></div><div class="toggle_vylO colorModeToggle_DEke"><button class="clean-btn toggleButton_gllP toggleButtonDisabled_aARS" type="button" disabled="" title="Switch between dark and light mode (currently light mode)" aria-label="Switch between dark and light mode (currently light mode)"><svg viewBox="0 0 24 24" width="24" height="24" class="lightToggleIcon_pyhR"><path fill="currentColor" d="M12,9c1.65,0,3,1.35,3,3s-1.35,3-3,3s-3-1.35-3-3S10.35,9,12,9 M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5 S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1 s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0 c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95 c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41 L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41 s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06 c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"></path></svg><svg viewBox="0 0 24 24" width="24" height="24" class="darkToggleIcon_wfgR"><path fill="currentColor" d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27C17.45,17.19,14.93,19,12,19 c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36 c-0.98,1.37-2.58,2.26-4.4,2.26c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"></path></svg></button></div><div class="searchBox_ZlJk"><div class="navbar__search searchBarContainer_NW3z"><input placeholder="Search" aria-label="Search" class="navbar__search-input"><div class="loadingRing_RJI3 searchBarLoadingRing_YnHq"><div></div><div></div><div></div><div></div></div></div></div></div></div><div role="presentation" class="navbar-sidebar__backdrop"></div></nav><div class="main-wrapper mainWrapper_z2l0 docsWrapper_BCFX"><button aria-label="Scroll back to top" class="clean-btn theme-back-to-top-button backToTopButton_sjWU" type="button"></button><div class="docPage__5DB"><aside class="theme-doc-sidebar-container docSidebarContainer_b6E3"><div class="sidebar_njMd"><nav class="menu thin-scrollbar menu_SIkG"><ul class="theme-doc-sidebar-menu menu__list"><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist" aria-expanded="false" href="/docs/v0.16/Overview">Overview</a><button aria-label="Toggle the collapsible sidebar category &#x27;Overview&#x27;" type="button" class="clean-btn menu__caret"></button></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist" aria-expanded="false" href="/docs/v0.16/GettingStarted">Getting Started</a><button aria-label="Toggle the collapsible sidebar category &#x27;Getting Started&#x27;" type="button" class="clean-btn menu__caret"></button></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--active" aria-expanded="true" href="/docs/v0.16/Configuration">Configuration</a><button aria-label="Toggle the collapsible sidebar category &#x27;Configuration&#x27;" type="button" class="clean-btn menu__caret"></button></div><ul style="display:block;overflow:visible;height:auto" class="menu__list"><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/Tutorial">Tutorial</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/BitBucket">BitBucket Cloud</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/GitHub">GitHub</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/GitLab">GitLab</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/Jira">Jira</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/Jenkins">Jenkins</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/Tapd">TAPD(Beta)</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/Zentao">Zentao(Beta)</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/SonarQube">SonarQube</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/webhook">Incoming Webhook</a></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link" tabindex="0" href="/docs/v0.16/Configuration/AdvancedMode">Blueprint Advanced Mode</a></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-2 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist menu__link--sublist-caret" aria-expanded="false" tabindex="0" href="/docs/v0.16/Configuration/Dashboards/AccessControl">Dashboard Configuration</a></div></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-2 menu__list-item"><a class="menu__link menu__link--active" aria-current="page" tabindex="0" href="/docs/v0.16/Configuration/TeamConfiguration">Team Configuration</a></li></ul></li><li class="theme-doc-sidebar-item-link theme-doc-sidebar-item-link-level-1 menu__list-item"><a class="menu__link" href="/docs/v0.16/DORA">DORA</a></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist" aria-expanded="false" href="/docs/v0.16/Metrics">Metrics</a><button aria-label="Toggle the collapsible sidebar category &#x27;Metrics&#x27;" type="button" class="clean-btn menu__caret"></button></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist" aria-expanded="false" href="/docs/v0.16/DataModels">Data Models</a><button aria-label="Toggle the collapsible sidebar category &#x27;Data Models&#x27;" type="button" class="clean-btn menu__caret"></button></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist" aria-expanded="false" href="/docs/v0.16/DeveloperManuals">Developer Manuals</a><button aria-label="Toggle the collapsible sidebar category &#x27;Developer Manuals&#x27;" type="button" class="clean-btn menu__caret"></button></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist" aria-expanded="false" href="/docs/v0.16/Plugins">Plugins</a><button aria-label="Toggle the collapsible sidebar category &#x27;Plugins&#x27;" type="button" class="clean-btn menu__caret"></button></div></li><li class="theme-doc-sidebar-item-category theme-doc-sidebar-item-category-level-1 menu__list-item menu__list-item--collapsed"><div class="menu__list-item-collapsible"><a class="menu__link menu__link--sublist" aria-expanded="false" href="/docs/v0.16/Troubleshooting">Troubleshooting</a><button aria-label="Toggle the collapsible sidebar category &#x27;Troubleshooting&#x27;" type="button" class="clean-btn menu__caret"></button></div></li></ul></nav></div></aside><main class="docMainContainer_gTbr"><div class="container padding-top--md padding-bottom--lg"><div class="row"><div class="col docItemCol_VOVn"><div class="docItemContainer_Djhp"><article><nav class="theme-doc-breadcrumbs breadcrumbsContainer_Z_bl" aria-label="Breadcrumbs"><ul class="breadcrumbs" itemscope="" itemtype="https://schema.org/BreadcrumbList"><li class="breadcrumbs__item"><a aria-label="Home page" class="breadcrumbs__link" href="/"><svg viewBox="0 0 24 24" class="breadcrumbHomeIcon_OVgt"><path d="M10 19v-5h4v5c0 .55.45 1 1 1h3c.55 0 1-.45 1-1v-7h1.7c.46 0 .68-.57.33-.87L12.67 3.6c-.38-.34-.96-.34-1.34 0l-8.36 7.53c-.34.3-.13.87.33.87H5v7c0 .55.45 1 1 1h3c.55 0 1-.45 1-1z" fill="currentColor"></path></svg></a></li><li itemscope="" itemprop="itemListElement" itemtype="https://schema.org/ListItem" class="breadcrumbs__item"><a class="breadcrumbs__link" itemprop="item" href="/docs/v0.16/Configuration"><span itemprop="name">Configuration</span></a><meta itemprop="position" content="1"></li><li itemscope="" itemprop="itemListElement" itemtype="https://schema.org/ListItem" class="breadcrumbs__item breadcrumbs__item--active"><span class="breadcrumbs__link" itemprop="name">Team Configuration</span><meta itemprop="position" content="2"></li></ul></nav><span class="theme-doc-version-badge badge badge--secondary">Version: v0.16</span><div class="tocCollapsible_ETCw theme-doc-toc-mobile tocMobile_ITEo"><button type="button" class="clean-btn tocCollapsibleButton_TO0P">On this page</button></div><div class="theme-doc-markdown markdown"><header><h1>Team Configuration</h1></header><h2 class="anchor anchorWithStickyNavbar_LWe7" id="what-is-team-configuration-and-how-it-works">What is &#x27;Team Configuration&#x27; and how it works?<a class="hash-link" href="#what-is-team-configuration-and-how-it-works" title="Direct link to heading">​</a></h2><p>To organize and display metrics by <code>team</code>, Apache DevLake needs to know about the team configuration in an organization, specifically:</p><ol><li>What are the teams?</li><li>Who are the users(unified identities)?</li><li>Which users belong to a team?</li><li>Which accounts(identities in specific tools) belong to the same user?</li></ol><p>Each of the questions above corresponds to a table in DevLake&#x27;s schema, illustrated below:</p><p><img loading="lazy" alt="image" src="/assets/images/teamflow0-e3332efd877ee18bb43b83f6ba789bac.png" width="976" height="411" class="img_ev3q"></p><ol><li><code>teams</code> table stores all the teams in the organization.</li><li><code>users</code> table stores the organization&#x27;s roster. An entry in the <code>users</code> table corresponds to a person in the org.</li><li><code>team_users</code> table stores which users belong to a team.</li><li><code>user_accounts</code> table stores which accounts belong to a user. An <code>account</code> refers to an identiy in a DevOps tool and is automatically created when importing data from that tool. For example, a <code>user</code> may have a GitHub <code>account</code> as well as a Jira <code>account</code>.</li></ol><p>Apache DevLake uses a simple heuristic algorithm based on emails and names to automatically map accounts to users and populate the <code>user_accounts</code> table.
When Apache DevLake cannot confidently map an <code>account</code> to a <code>user</code> due to insufficient information, it allows DevLake users to manually configure the mapping to ensure accuracy and integrity.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="a-step-by-step-guide">A step-by-step guide<a class="hash-link" href="#a-step-by-step-guide" title="Direct link to heading">​</a></h2><p>In the following sections, we&#x27;ll walk through how to configure teams and create the five aforementioned tables (<code>teams</code>, <code>users</code>, <code>team_users</code>, <code>accounts</code>, and <code>user_accounts</code>).
The overall workflow is:</p><ol><li>Create the <code>teams</code> table</li><li>Create the <code>users</code> and <code>team_users</code> table</li><li>Populate the <code>accounts</code> table via data collection</li><li>Run a heuristic algorithm to populate <code>user_accounts</code> table</li><li>Manually update <code>user_accounts</code> when the algorithm can&#x27;t catch everything</li></ol><p>Note:</p><ol><li>Please replace <code>/path/to/*.csv</code> with the absolute path of the CSV file you&#x27;d like to upload.</li><li>Please replace <code>127.0.0.1:4000</code> with your actual Apache DevLake ConfigUI service IP and port number.</li></ol><h2 class="anchor anchorWithStickyNavbar_LWe7" id="step-1---create-the-teams-table">Step 1 - Create the <code>teams</code> table<a class="hash-link" href="#step-1---create-the-teams-table" title="Direct link to heading">​</a></h2><p>You can create the <code>teams</code> table by sending a PUT request to <code>/plugins/org/teams.csv</code> with a <code>teams.csv</code> file. To jumpstart the process, you can download a template <code>teams.csv</code> from <code>/plugins/org/teams.csv?fake_data=true</code>. Below are the detailed instructions:</p><p>a. Download the template <code>teams.csv</code> file</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">i.  GET http://127.0.0.1:4000/api/plugins/org/teams.csv?fake_data=true (pasting the URL into your browser will download the template)</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">ii. If you prefer using curl:</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    curl --location --request GET &#x27;http://127.0.0.1:4000/api/plugins/org/teams.csv?fake_data=true&#x27;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>b. Fill out <code>teams.csv</code> file and upload it to DevLake (If you are using Excel to modify the CSV file, please save it with UTF-8 encoding. See <a href="https://answers.microsoft.com/en-us/msoffice/forum/all/how-can-i-save-a-csv-with-utf-8-encoding-using/12801501-c1e4-4a64-80d9-96b680b64cfe" target="_blank" rel="noopener noreferrer">how</a>)</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">i. Fill out `teams.csv` with your org data. Please don&#x27;t modify the column headers or the file suffix.</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">ii. Upload `teams.csv` to DevLake with the following curl command: </span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">curl --location --request PUT &#x27;http://127.0.0.1:4000/api/plugins/org/teams.csv&#x27; --form &#x27;file=@&quot;/path/to/teams.csv&quot;&#x27;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">iii. The PUT request would populate the `teams` table with data from `teams.csv` file.</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">You can connect to the database and verify the data in the `teams` table.</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">See Appendix for how to connect to the database.</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p><img loading="lazy" alt="image" src="/assets/images/teamflow3-b45b67eed4d0241da98eb650d276c596.png" width="1458" height="127" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="step-2---create-the-users-and-team_users-table">Step 2 - Create the <code>users</code> and <code>team_users</code> table<a class="hash-link" href="#step-2---create-the-users-and-team_users-table" title="Direct link to heading">​</a></h2><p>You can create the <code>users</code> and <code>team_users</code> table by sending a single PUT request to <code>/plugins/org/users.csv</code> with a <code>users.csv</code> file. To jumpstart the process, you can download a template <code>users.csv</code> from <code>/plugins/org/users.csv?fake_data=true</code>. Below are the detailed instructions:</p><p>a. Download the template <code>users.csv</code> file</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">i.  GET http://127.0.0.1:4000/api/plugins/org/users.csv?fake_data=true (pasting the URL into your browser will download the template)</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">ii. If you prefer using curl:</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">curl --location --request GET &#x27;http://127.0.0.1:4000/api/plugins/org/users.csv?fake_data=true&#x27;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>b. Fill out <code>users.csv</code> and upload to DevLake (If you are using Excel to modify the CSV file, please save it with UTF-8 encoding. See <a href="https://answers.microsoft.com/en-us/msoffice/forum/all/how-can-i-save-a-csv-with-utf-8-encoding-using/12801501-c1e4-4a64-80d9-96b680b64cfe" target="_blank" rel="noopener noreferrer">how</a>)</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">i.  Fill out `users.csv` with your org data. Please don&#x27;t modify the column headers or the file suffix</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">ii. Upload `users.csv` to DevLake with the following curl command:</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">curl --location --request PUT &#x27;http://127.0.0.1:4000/api/plugins/org/users.csv&#x27; --form &#x27;file=@&quot;/path/to/users.csv&quot;&#x27;</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">iii. The PUT request would populate the `users` table along with the `team_users` table with data from `users.csv` file.</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">You can connect to the database and verify these two tables.</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p><img loading="lazy" alt="image" src="/assets/images/teamflow1-73bddf3280eff9dd9b82a98ea2150ac3.png" width="1429" height="205" class="img_ev3q"></p><p><img loading="lazy" alt="image" src="/assets/images/teamflow2-cb7557cb19dee75f241a741049333e04.png" width="1452" height="186" class="img_ev3q"></p><p>c. If you ever want to update <code>team_users</code> or <code>users</code> table, simply upload the updated <code>users.csv</code> to DevLake again following step b.</p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="step-3---populate-the-accounts-table-via-data-collection">Step 3 - Populate the <code>accounts</code> table via data collection<a class="hash-link" href="#step-3---populate-the-accounts-table-via-data-collection" title="Direct link to heading">​</a></h2><p>The <code>accounts</code> table is automatically populated when you collect data from data sources like GitHub and Jira through DevLake.</p><p>For example, the GitHub plugin would create one entry in the <code>accounts</code> table for each GitHub user involved in your repository.
For demo purposes, we&#x27;ll insert some mock data into the <code>accounts</code> table using SQL:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">INSERT INTO `accounts` (`id`, `created_at`, `updated_at`, `_raw_data_params`, `_raw_data_table`, `_raw_data_id`, `_raw_data_remark`, `email`, `full_name`, `user_name`, `avatar_url`, `organization`, `created_date`, `status`)</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">VALUES</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        (&#x27;github:GithubAccount:1:1234&#x27;, &#x27;2022-07-12 10:54:09.632&#x27;, &#x27;2022-07-12 10:54:09.632&#x27;, &#x27;{\&quot;ConnectionId\&quot;:1,\&quot;Owner\&quot;:\&quot;apache\&quot;,\&quot;Repo\&quot;:\&quot;incubator-devlake\&quot;}&#x27;, &#x27;_raw_github_api_pull_request_reviews&#x27;, 28, &#x27;&#x27;, &#x27;TyroneKCummings@teleworm.us&#x27;, &#x27;&#x27;, &#x27;Tyrone K. Cummings&#x27;, &#x27;https://avatars.githubusercontent.com/u/101256042?u=a6e460fbaffce7514cbd65ac739a985f5158dabc&amp;v=4&#x27;, &#x27;&#x27;, NULL, 0),</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        (&#x27;jira:JiraAccount:1:629cdf&#x27;, &#x27;2022-07-12 10:54:09.632&#x27;, &#x27;2022-07-12 10:54:09.632&#x27;, &#x27;{\&quot;ConnectionId\&quot;:1,\&quot;BoardId\&quot;:\&quot;76\&quot;}&#x27;, &#x27;_raw_jira_api_users&#x27;, 5, &#x27;&#x27;, &#x27;DorothyRUpdegraff@dayrep.com&#x27;, &#x27;&#x27;, &#x27;Dorothy R. Updegraff&#x27;, &#x27;https://avatars.jiraxxxx158dabc&amp;v=4&#x27;, &#x27;&#x27;, NULL, 0);</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain" style="display:inline-block"></span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p><img loading="lazy" alt="image" src="/assets/images/teamflow4-53a9ee2bc9385f4b580775213de1fb42.png" width="1452" height="71" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="step-4---run-a-heuristic-algorithm-to-populate-user_accounts-table">Step 4 - Run a heuristic algorithm to populate <code>user_accounts</code> table<a class="hash-link" href="#step-4---run-a-heuristic-algorithm-to-populate-user_accounts-table" title="Direct link to heading">​</a></h2><p>Now that we have data in both the <code>users</code> and <code>accounts</code> table, we can tell DevLake to infer the mappings between <code>users</code> and <code>accounts</code> with a simple heuristic algorithm based on names and emails.</p><p>a. Send an API request to DevLake to run the mapping algorithm</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">curl --location --request POST &#x27;127.0.0.1:4000/api/pipelines&#x27; \</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">--header &#x27;Content-Type: application/json&#x27; \</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">--data-raw &#x27;{</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &quot;name&quot;: &quot;test&quot;,</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    &quot;plan&quot;:[</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        [</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">            {</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">                &quot;plugin&quot;: &quot;org&quot;,</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">                &quot;subtasks&quot;:[&quot;connectUserAccountsExact&quot;]</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">            }</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        ]</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">    ]</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">}&#x27;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>b. After successful execution, you can verify the data in <code>user_accounts</code> in the database. </p><p><img loading="lazy" alt="image" src="/assets/images/teamflow5-79508a7cbd6b791786f77db90373c788.png" width="1399" height="229" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="step-5---manually-update-user_accounts-when-the-algorithm-cant-catch-everything">Step 5 - Manually update <code>user_accounts</code> when the algorithm can&#x27;t catch everything<a class="hash-link" href="#step-5---manually-update-user_accounts-when-the-algorithm-cant-catch-everything" title="Direct link to heading">​</a></h2><p>It is recommended to examine the generated <code>user_accounts</code> table after running the algorithm.
We&#x27;ll demonstrate how to manually update <code>user_accounts</code> when the mapping is inaccurate/incomplete in this section.
To make manual verification easier, DevLake provides an API for users to download <code>user_accounts</code> as a CSV file.
Alternatively, you can verify and modify <code>user_accounts</code> all by SQL, see Appendix for more info.</p><p>a. GET <a href="http://127.0.0.1:4000/api/plugins/org/user_account_mapping.csv(pasting" target="_blank" rel="noopener noreferrer">http://127.0.0.1:4000/api/plugins/org/user_account_mapping.csv(pasting</a> the URL into your browser will download the file). If you prefer using curl:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">curl --location --request GET &#x27;http://127.0.0.1:4000/api/plugins/org/user_account_mapping.csv&#x27;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p><img loading="lazy" alt="image" src="/assets/images/teamflow6-681d45c768beb8f3f9001268b0990c2e.png" width="735" height="151" class="img_ev3q"></p><p>b. If you find the mapping inaccurate or incomplete, you can modify the <code>user_account_mapping.csv</code> file and then upload it to DevLake.
For example, here we change the <code>UserId</code> of row &#x27;Id=github:GithubAccount:1:1234&#x27; in the <code>user_account_mapping.csv</code> file to 2.</p><p>c. Save and upload the updated <code>user_account_mapping.csv</code> file with the following curl command (If you are using Excel to modify the CSV file, please save it with UTF-8 encoding. See <a href="https://answers.microsoft.com/en-us/msoffice/forum/all/how-can-i-save-a-csv-with-utf-8-encoding-using/12801501-c1e4-4a64-80d9-96b680b64cfe" target="_blank" rel="noopener noreferrer">how</a>):</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">curl --location --request PUT &#x27;http://127.0.0.1:4000/api/plugins/org/user_account_mapping.csv&#x27; --form &#x27;file=@&quot;/path/to/user_account_mapping.csv&quot;&#x27;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><p>d. You can verify the data in the <code>user_accounts</code> table has been updated.</p><p><img loading="lazy" alt="image" src="/assets/images/teamflow7-68cb374cc7bb9047659c3896f6e6acba.png" width="1396" height="239" class="img_ev3q"></p><h2 class="anchor anchorWithStickyNavbar_LWe7" id="appendix-a-how-to-connect-to-the-database">Appendix A: how to connect to the database<a class="hash-link" href="#appendix-a-how-to-connect-to-the-database" title="Direct link to heading">​</a></h2><p>Here we use MySQL as an example. You can install database management tools like Sequel Ace, DataGrip, MySQLWorkbench, etc.</p><p>Or through the command line:</p><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">mysql -h &lt;ip&gt; -u &lt;username&gt; -p -P &lt;port&gt;</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h2 class="anchor anchorWithStickyNavbar_LWe7" id="appendix-b-how-to-examine-user_accounts-via-sql">Appendix B: how to examine <code>user_accounts</code> via SQL<a class="hash-link" href="#appendix-b-how-to-examine-user_accounts-via-sql" title="Direct link to heading">​</a></h2><div class="codeBlockContainer_Ckt0 theme-code-block" style="--prism-color:#393A34;--prism-background-color:#f6f8fa"><div class="codeBlockContent_biex"><pre tabindex="0" class="prism-code language-text codeBlock_bY9V thin-scrollbar"><code class="codeBlockLines_e6Vv"><span class="token-line" style="color:#393A34"><span class="token plain">SELECT a.id as account_id, a.email, a.user_name as account_user_name, u.id as user_id, u.name as real_name</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">FROM accounts a</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        join user_accounts ua on a.id = ua.account_id</span><br></span><span class="token-line" style="color:#393A34"><span class="token plain">        join users u on ua.user_id = u.id</span><br></span></code></pre><div class="buttonGroup__atx"><button type="button" aria-label="Copy code to clipboard" title="Copy" class="clean-btn"><span class="copyButtonIcons_eSgA" aria-hidden="true"><svg class="copyButtonIcon_y97N" viewBox="0 0 24 24"><path d="M19,21H8V7H19M19,5H8A2,2 0 0,0 6,7V21A2,2 0 0,0 8,23H19A2,2 0 0,0 21,21V7A2,2 0 0,0 19,5M16,1H4A2,2 0 0,0 2,3V17H4V3H16V1Z"></path></svg><svg class="copyButtonSuccessIcon_LjdS" viewBox="0 0 24 24"><path d="M21,7L9,19L3.5,13.5L4.91,12.09L9,16.17L19.59,5.59L21,7Z"></path></svg></span></button></div></div></div><h2 class="anchor anchorWithStickyNavbar_LWe7" id="troubleshooting">Troubleshooting<a class="hash-link" href="#troubleshooting" title="Direct link to heading">​</a></h2><p>If you run into any problem, please check the <a href="/docs/v0.16/Troubleshooting/Installation">Troubleshooting</a> or <a href="https://github.com/apache/incubator-devlake/issues" target="_blank" rel="noopener noreferrer">create an issue</a></p></div><footer class="theme-doc-footer docusaurus-mt-lg"><div class="theme-doc-footer-edit-meta-row row"><div class="col"><a href="https://github.com/apache/incubator-devlake-website/edit/main/versioned_docs/version-v0.16/Configuration/TeamConfiguration.md" target="_blank" rel="noreferrer noopener" class="theme-edit-this-page"><svg fill="currentColor" height="20" width="20" viewBox="0 0 40 40" class="iconEdit_Z9Sw" aria-hidden="true"><g><path d="m34.5 11.7l-3 3.1-6.3-6.3 3.1-3q0.5-0.5 1.2-0.5t1.1 0.5l3.9 3.9q0.5 0.4 0.5 1.1t-0.5 1.2z m-29.5 17.1l18.4-18.5 6.3 6.3-18.4 18.4h-6.3v-6.2z"></path></g></svg>Edit this page</a></div><div class="col lastUpdated_vwxv"></div></div></footer></article><nav class="pagination-nav docusaurus-mt-lg" aria-label="Docs pages navigation"><a class="pagination-nav__link pagination-nav__link--prev" href="/docs/v0.16/Configuration/Dashboards/GrafanaUserGuide"><div class="pagination-nav__sublabel">Previous</div><div class="pagination-nav__label">Grafana User Guide</div></a><a class="pagination-nav__link pagination-nav__link--next" href="/docs/v0.16/DORA"><div class="pagination-nav__sublabel">Next</div><div class="pagination-nav__label">DORA</div></a></nav></div></div><div class="col col--3"><div class="tableOfContents_bqdL thin-scrollbar theme-doc-toc-desktop"><ul class="table-of-contents table-of-contents__left-border"><li><a href="#what-is-team-configuration-and-how-it-works" class="table-of-contents__link toc-highlight">What is &#39;Team Configuration&#39; and how it works?</a></li><li><a href="#a-step-by-step-guide" class="table-of-contents__link toc-highlight">A step-by-step guide</a></li><li><a href="#step-1---create-the-teams-table" class="table-of-contents__link toc-highlight">Step 1 - Create the <code>teams</code> table</a></li><li><a href="#step-2---create-the-users-and-team_users-table" class="table-of-contents__link toc-highlight">Step 2 - Create the <code>users</code> and <code>team_users</code> table</a></li><li><a href="#step-3---populate-the-accounts-table-via-data-collection" class="table-of-contents__link toc-highlight">Step 3 - Populate the <code>accounts</code> table via data collection</a></li><li><a href="#step-4---run-a-heuristic-algorithm-to-populate-user_accounts-table" class="table-of-contents__link toc-highlight">Step 4 - Run a heuristic algorithm to populate <code>user_accounts</code> table</a></li><li><a href="#step-5---manually-update-user_accounts-when-the-algorithm-cant-catch-everything" class="table-of-contents__link toc-highlight">Step 5 - Manually update <code>user_accounts</code> when the algorithm can&#39;t catch everything</a></li><li><a href="#appendix-a-how-to-connect-to-the-database" class="table-of-contents__link toc-highlight">Appendix A: how to connect to the database</a></li><li><a href="#appendix-b-how-to-examine-user_accounts-via-sql" class="table-of-contents__link toc-highlight">Appendix B: how to examine <code>user_accounts</code> via SQL</a></li><li><a href="#troubleshooting" class="table-of-contents__link toc-highlight">Troubleshooting</a></li></ul></div></div></div></div></main></div></div><footer class="footer footer--dark"><div class="container container-fluid"><div class="row footer__links"><div class="col footer__col"><div class="footer__title">Docs</div><ul class="footer__items clean-list"><li class="footer__item"><a class="footer__link-item" href="/docs/GettingStarted">Getting Started</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/DataModels/DevLakeDomainLayerSchema">Data Models</a></li><li class="footer__item"><a class="footer__link-item" href="/docs/Metrics">Engineering Metrics</a></li></ul></div><div class="col footer__col"><div class="footer__title">Community</div><ul class="footer__items clean-list"><li class="footer__item"><a href="https://join.slack.com/t/devlake-io/shared_invite/zt-20envwfbk-JUTZ4z9jSeRnrvNhBFLg9w" target="_blank" rel="noopener noreferrer" class="footer__link-item">Slack</a></li><li class="footer__item"><a href="https://github.com/apache/incubator-devlake/issues" target="_blank" rel="noopener noreferrer" class="footer__link-item">GitHub Issue Tracker</a></li><li class="footer__item"><a href="https://github.com/apache/incubator-devlake-website/issues" target="_blank" rel="noopener noreferrer" class="footer__link-item">GitHub Issue Tracker For Docs</a></li></ul></div><div class="col footer__col"><div class="footer__title">More</div><ul class="footer__items clean-list"><li class="footer__item"><a href="https://github.com/apache/incubator-devlake" target="_blank" rel="noopener noreferrer" class="footer__link-item">GitHub</a></li><li class="footer__item"><a href="https://twitter.com/ApacheDevLake" target="_blank" rel="noopener noreferrer" class="footer__link-item">Twitter</a></li><li class="footer__item"><a class="footer__link-item" href="/community/trademark">Trademark Guidelines</a></li></ul></div></div><div class="footer__bottom text--center"><div class="footer__copyright">
        <div style="margin-top: 20px">
          <a href="https://incubator.apache.org/" target="_blank"><img style="height:40px; margin-bottom: 10px; margin-top: 10px" alt="Apache Software Foundation" src="/img/apache-incubator.svg"></a>
          <p style="text-align:left; font-weight: 300; font-size: 0.8em;">Apache DevLake is an effort undergoing incubation at The Apache Software Foundation (ASF), sponsored by the Apache Incubator. Incubation is required of all newly accepted projects until a further review indicates that the infrastructure, communications, and decision making process have stabilized in a manner consistent with other successful ASF projects. While incubation status is not necessarily a reflection of the completeness or stability of the code, it does indicate that the project has yet to be fully endorsed by the ASF.</p>
          <p style="text-align:left; font-weight: 300; font-size: 0.8em;">Copyright ©2024 Apache DevLake, DevLake, Apache, the Apache feather logo and the Apache DevLake project logo are either registered trademarks or trademarks of The Apache Software Foundation in the United States and other countries.</p>
        </div> 
        </div></div></div></footer></div>
<script src="/assets/js/runtime~main.027efac3.js"></script>
<script src="/assets/js/main.0ab36cb3.js"></script>
</body>
</html>