models: Add `external_account` in custom profile field types.

Add new custom profile field type, External account.
External account field links user's social media
profile with account. e.g. GitHub, Twitter, etc.

Fixes part of #12302

frontend_tests/node_tests/settings_profile_fields.js

@@ -7,17 +7,27 @@ set_global('Sortable', {create: () => {}});
 
 const SHORT_TEXT_ID = 1;
 const CHOICE_ID = 3;
+const EXTERNAL_ACCOUNT_ID = 7;
+
+const SHORT_TEXT_NAME = "Short Text";
+const CHOICE_NAME = "Choice";
+const EXTERNAL_ACCOUNT_NAME = "External account";
 
 page_params.custom_profile_fields = {};
+page_params.realm_default_external_accounts = JSON.stringify({});
 
 page_params.custom_profile_field_types = {
     SHORT_TEXT: {
         id: SHORT_TEXT_ID,
-        name: "Short Text",
+        name: SHORT_TEXT_NAME,
     },
     CHOICE: {
         id: CHOICE_ID,
-        name: "Choice",
+        name: CHOICE_NAME,
+    },
+    EXTERNAL_ACCOUNT: {
+        id: EXTERNAL_ACCOUNT_ID,
+        name: EXTERNAL_ACCOUNT_NAME,
     },
 };
 
@@ -78,6 +88,25 @@ run_test('populate_profile_fields', () => {
                 },
             ]),
         },
+        {
+            type: EXTERNAL_ACCOUNT_ID,
+            id: 20,
+            name: 'github profile',
+            hint: 'username only',
+            field_data: JSON.stringify({
+                subtype: 'github',
+            }),
+        },
+        {
+            type: EXTERNAL_ACCOUNT_ID,
+            id: 21,
+            name: 'zulip profile',
+            hint: 'username only',
+            field_data: JSON.stringify({
+                subtype: 'custom',
+                url_pattern: 'https://chat.zulip.com/%(username)s',
+            }),
+        },
     ];
     const expected_template_data = [
         {
@@ -85,25 +114,59 @@ run_test('populate_profile_fields', () => {
                 id: 10,
                 name: 'favorite color',
                 hint: 'blue?',
-                type: 'Short Text',
+                type: SHORT_TEXT_NAME,
                 choices: [],
                 is_choice_field: false,
+                is_external_account_field: false,
             },
             can_modify: true,
+            realm_default_external_accounts:
+                page_params.realm_default_external_accounts,
         },
         {
             profile_field: {
                 id: 30,
                 name: 'meal',
                 hint: 'lunch',
-                type: 'Choice',
+                type: CHOICE_NAME,
                 choices: [
                     {order: 0, value: 0, text: 'lunch'},
                     {order: 1, value: 1, text: 'dinner'},
                 ],
                 is_choice_field: true,
+                is_external_account_field: false,
             },
             can_modify: true,
+            realm_default_external_accounts:
+                page_params.realm_default_external_accounts,
+        },
+        {
+            profile_field: {
+                id: 20,
+                name: 'github profile',
+                hint: 'username only',
+                type: EXTERNAL_ACCOUNT_NAME,
+                choices: [],
+                is_choice_field: false,
+                is_external_account_field: true,
+            },
+            can_modify: true,
+            realm_default_external_accounts:
+                page_params.realm_default_external_accounts,
+        },
+        {
+            profile_field: {
+                id: 21,
+                name: 'zulip profile',
+                hint: 'username only',
+                type: EXTERNAL_ACCOUNT_NAME,
+                choices: [],
+                is_choice_field: false,
+                is_external_account_field: true,
+            },
+            can_modify: true,
+            realm_default_external_accounts:
+                page_params.realm_default_external_accounts,
         },
     ];
 

static/js/admin.js

@@ -71,6 +71,7 @@ exports.build_page = function () {
         plan_includes_wide_organization_logo: page_params.plan_includes_wide_organization_logo,
         upgrade_text_for_wide_organization_logo:
             page_params.upgrade_text_for_wide_organization_logo,
+        realm_default_external_accounts: page_params.realm_default_external_accounts,
     };
 
     options.admin_settings_label = admin_settings_label;

static/js/popovers.js

@@ -104,6 +104,7 @@ function get_custom_profile_field_data(user, field, field_types, dateFormat) {
     profile_field.name = field.name;
     profile_field.is_user_field = false;
     profile_field.is_link = field_type === field_types.URL.id;
+    profile_field.is_external_account = field_type === field_types.EXTERNAL_ACCOUNT.id;
     profile_field.type = field_type;
 
     switch (field_type) {
@@ -124,6 +125,11 @@ function get_custom_profile_field_data(user, field, field_types, dateFormat) {
         profile_field.value = field_value.value;
         profile_field.rendered_value = field_value.rendered_value;
         break;
+    case field_types.EXTERNAL_ACCOUNT.id:
+        profile_field.value = field_value.value;
+        profile_field.field_data = JSON.parse(field.field_data);
+        profile_field.link = settings_profile_fields.get_external_account_link(profile_field);
+        break;
     default:
         profile_field.value = field_value.value;
     }

static/js/settings_account.js

@@ -90,6 +90,7 @@ exports.append_custom_profile_fields = function (element_id, user_id) {
     all_field_template_types[all_field_types.CHOICE.id] = "choice";
     all_field_template_types[all_field_types.USER.id] = "user";
     all_field_template_types[all_field_types.DATE.id] = "date";
+    all_field_template_types[all_field_types.EXTERNAL_ACCOUNT.id] = "text";
 
     all_custom_fields.forEach(function (field) {
         var field_value = people.get_custom_profile_data(user_id, field.id);

static/js/settings_profile_fields.js

@@ -76,6 +76,15 @@ function read_choice_field_data_from_form(field_elem) {
     return field_data;
 }
 
+function read_external_account_field_data(field_elem) {
+    var field_data = {};
+    field_data.subtype = $(field_elem).find('select[name=external_acc_field_type]').val();
+    if (field_data.subtype === "custom") {
+        field_data.url_pattern = $(field_elem).find('input[name=url_pattern]').val();
+    }
+    return field_data;
+}
+
 function update_choice_delete_btn(container, display_flag) {
     var no_of_choice_row = container.find(".choice-row").length;
 
@@ -106,12 +115,20 @@ function clear_form_data() {
     create_choice_row($("#profile_field_choices"));
     update_choice_delete_btn($("#profile_field_choices"), false);
     $("#profile_field_choices_row").hide();
+    // Clear external account field form
+    $("#custom_field_url_pattern").val("");
+    $("#custom_external_account_url_pattern").hide();
+    $("#profile_field_external_accounts").hide();
+    $("#profile_field_external_accounts_type").val(0);
 }
 
 function read_field_data_from_form(field_type_id, field_elem) {
     // Only read field data if we are creating a choice field
+    // or external account field.
     if (field_type_id === field_types.CHOICE.id) {
         return read_choice_field_data_from_form(field_elem);
+    } else if (field_type_id === field_types.EXTERNAL_ACCOUNT.id) {
+        return read_external_account_field_data(field_elem);
     }
 }
 
@@ -121,7 +138,6 @@ function create_profile_field(e) {
 
     var field_data = {};
     var field_type = $('#profile_field_type').val();
-
     var opts = {
         success_continuation: clear_form_data,
     };
@@ -186,6 +202,15 @@ exports.parse_field_choices_from_field_data = function (field_data) {
     return choices;
 };
 
+function set_up_external_account_field_edit_form(field_elem, url_pattern_val) {
+    if (field_elem.form.find('select[name=external_acc_field_type]').val() === 'custom') {
+        field_elem.form.find('input[name=url_pattern]').val(url_pattern_val);
+        field_elem.form.find('.custom_external_account_detail').show();
+    } else {
+        field_elem.form.find('.custom_external_account_detail').hide();
+    }
+}
+
 function set_up_choices_field_edit_form(profile_field, field_data) {
     // Re-render field choices in edit form to load initial choice data
     var choice_list = profile_field.form.find('.edit_profile_field_choices_container');
@@ -229,6 +254,11 @@ function open_edit_form(e) {
         set_up_choices_field_edit_form(profile_field, field_data);
     }
 
+    if (parseInt(field.type, 10) === field_types.EXTERNAL_ACCOUNT.id) {
+        profile_field.form.find('select[name=external_acc_field_type]').val(field_data.subtype);
+        set_up_external_account_field_edit_form(profile_field, field_data.url_pattern);
+    }
+
     profile_field.form.find('.reset').on("click", function () {
         profile_field.form.hide();
         profile_field.row.show();
@@ -254,6 +284,11 @@ function open_edit_form(e) {
 
     profile_field.form.find(".edit_profile_field_choices_container").on("input", ".choice-row input", add_choice_row);
     profile_field.form.find(".edit_profile_field_choices_container").on("click", "button.delete-choice", delete_choice_row);
+    $(".profile_field_external_accounts_edit select").on('change', function (e) {
+        var field_id = $(e.target).closest('.profile-field-form').attr('data-profile-field-id');
+        var field_form = get_profile_field_info(field_id);
+        set_up_external_account_field_edit_form(field_form, "");
+    });
 }
 
 exports.reset = function () {
@@ -307,8 +342,11 @@ exports.do_populate_profile_fields = function (profile_fields_data) {
                         type: exports.field_type_id_to_string(profile_field.type),
                         choices: choices,
                         is_choice_field: profile_field.type === field_types.CHOICE.id,
+                        is_external_account_field: profile_field.type ===
+                                                    field_types.EXTERNAL_ACCOUNT.id,
                     },
                     can_modify: page_params.is_admin,
+                    realm_default_external_accounts: page_params.realm_default_external_accounts,
                 }
             )
         );
@@ -355,6 +393,46 @@ function set_up_choices_field() {
     $("#profile_field_choices").on("click", "button.delete-choice", delete_choice_row);
 }
 
+function set_up_external_account_field() {
+    var field_elem = $("#profile_field_external_accounts");
+    var field_url_pattern_elem = $("#custom_external_account_url_pattern");
+
+    $('#profile_field_type').on('change', function (e) {
+        var selected_field_id = parseInt($(e.target).val(), 10);
+        if (selected_field_id === field_types.EXTERNAL_ACCOUNT.id) {
+            field_elem.show();
+            if ($("#profile_field_external_accounts_type").val() === 'custom') {
+                field_url_pattern_elem.show();
+            } else {
+                field_url_pattern_elem.hide();
+            }
+        } else {
+            field_url_pattern_elem.hide();
+            field_elem.hide();
+        }
+    });
+    $("#profile_field_external_accounts_type").on("change", function () {
+        if ($("#profile_field_external_accounts_type").val() === 'custom') {
+            field_url_pattern_elem.show();
+        } else {
+            field_url_pattern_elem.hide();
+        }
+    });
+}
+
+exports.get_external_account_link = function (field) {
+    var field_subtype = field.field_data.subtype;
+    var field_url_pattern;
+
+    if (field_subtype === 'custom') {
+        field_url_pattern = field.field_data.url_pattern;
+    } else {
+        field_url_pattern =
+            page_params.realm_default_external_accounts[field_subtype].url_pattern;
+    }
+    return field_url_pattern.replace('%(username)s', field.value);
+};
+
 exports.set_up = function () {
     exports.build_page();
     exports.maybe_disable_widgets();
@@ -371,6 +449,7 @@ exports.build_page = function () {
     $("#profile-field-settings").on("click", "#add-custom-profile-field-btn", create_profile_field);
     $("#admin_profile_fields_table").on("click", ".open-edit-form", open_edit_form);
     set_up_choices_field();
+    set_up_external_account_field();
     clear_form_data();
 };
 

static/templates/admin_profile_field_list.handlebars

@@ -48,6 +48,21 @@
                 </div>
             </div>
             {{/if}}
+            {{#if is_external_account_field}}
+            <div class="input-group profile_field_external_accounts_edit">
+                <label for="external_acc_field_type">{{t "External account type" }}</label>
+                <select name="external_acc_field_type">
+                    {{#each ../realm_default_external_accounts}}
+                    <option value='{{@key}}'>{{this.text}}</option>
+                    {{/each}}
+                    <option value="custom">{{t 'Custom' }}</option>
+                </select>
+            </div>
+            <div class="input-group custom_external_account_detail">
+                <label for="url_pattern">{{t "URL pattern" }}</label>
+                <input type="url" name="url_pattern" autocomplete="off" maxlength="80" />
+            </div>
+            {{/if}}
             <div class="input-group">
                 <button type="button" class="button rounded sea-green submit">
                     {{t 'Save changes' }}

static/templates/settings/profile-field-settings-admin.handlebars

@@ -41,6 +41,19 @@
                         <tbody id="profile_field_choices" class="profile-field-choices"></tbody>
                     </table>
                 </div>
+                <div class="control-group" id="profile_field_external_accounts">
+                    <label for="profile_field_external_accounts_type" class="control-label">{{t "External account type" }}</label>
+                    <select id="profile_field_external_accounts_type" name="external_acc_field_type">
+                        {{#each realm_default_external_accounts}}
+                        <option value='{{@key}}'>{{this.text}}</option>
+                        {{/each}}
+                        <option value="custom">{{t 'Custom' }}</option>
+                    </select>
+                </div>
+                <div class="control-group" id="custom_external_account_url_pattern">
+                    <label for="custom_field_url_pattern" class="control-label">{{t "URL pattern" }}</label>
+                    <input type="url" id="custom_field_url_pattern" name="url_pattern" autocomplete="off" maxlength="80" />
+                </div>
                 <button type="submit" class="button rounded sea-green" id="add-custom-profile-field-btn">
                     {{t 'Add profile field' }}
                 </button>

static/templates/user_profile_modal.handlebars

@@ -51,6 +51,8 @@
                     </div>
                     {{else if this.is_link}}
                     <a href={{this.value}} target="_blank" class="value">{{this.value}}</a>
+                    {{else if this.is_external_account}}
+                    <a href={{this.link}} target="_blank" class="value">{{this.value}}</a>
                 {{else}}
                     {{#if this.rendered_value}}
                     <div class="value rendered_markdown">{{{this.rendered_value}}}</div>

zerver/lib/actions.py

@@ -5385,7 +5385,8 @@ def try_add_realm_custom_profile_field(realm: Realm, name: str, field_type: int,
                                        field_data: Optional[ProfileFieldData]=None) -> CustomProfileField:
     field = CustomProfileField(realm=realm, name=name, field_type=field_type)
     field.hint = hint
-    if field.field_type == CustomProfileField.CHOICE:
+    if (field.field_type == CustomProfileField.CHOICE or
+            field.field_type == CustomProfileField.EXTERNAL_ACCOUNT):
         field.field_data = ujson.dumps(field_data or {})
 
     field.save()
@@ -5410,7 +5411,8 @@ def try_update_realm_custom_profile_field(realm: Realm, field: CustomProfileFiel
                                           field_data: Optional[ProfileFieldData]=None) -> None:
     field.name = name
     field.hint = hint
-    if field.field_type == CustomProfileField.CHOICE:
+    if (field.field_type == CustomProfileField.CHOICE or
+            field.field_type == CustomProfileField.EXTERNAL_ACCOUNT):
         field.field_data = ujson.dumps(field_data or {})
     field.save()
     notify_realm_custom_profile_fields(realm, 'update')

zerver/lib/events.py

@@ -53,7 +53,7 @@ from zerver.models import Client, Message, Realm, UserPresence, UserProfile, Cus
     get_default_stream_groups, CustomProfileField, Stream
 from zproject.backends import email_auth_enabled, password_auth_enabled
 from version import ZULIP_VERSION
-
+from zerver.lib.external_accounts import DEFAULT_EXTERNAL_ACCOUNTS
 
 def get_raw_user_data(realm: Realm, client_gravatar: bool) -> Dict[int, Dict[str, str]]:
     user_dicts = get_realm_user_dicts(realm.id)
@@ -218,6 +218,8 @@ def fetch_initial_state_data(user_profile: UserProfile,
         state['realm_plan_type'] = realm.plan_type
         state['plan_includes_wide_organization_logo'] = realm.plan_type != Realm.LIMITED
         state['upgrade_text_for_wide_organization_logo'] = str(Realm.UPGRADE_TEXT_STANDARD)
+        state['realm_default_external_accounts'] = DEFAULT_EXTERNAL_ACCOUNTS
+
         if realm.notifications_stream and not realm.notifications_stream.deactivated:
             notifications_stream = realm.notifications_stream
             state['realm_notifications_stream_id'] = notifications_stream.id

zerver/lib/external_accounts.py

@@ -0,0 +1,39 @@
+"""
+    This module stores data for "External Account" custom profile field.
+"""
+from typing import Optional
+from django.utils.translation import ugettext as _
+
+from zerver.lib.validator import check_required_string, \
+    check_url_pattern, check_dict_only
+from zerver.lib.types import ProfileFieldData
+
+DEFAULT_EXTERNAL_ACCOUNTS = {
+    "twitter": {
+        "text": "Twitter",
+        "url_pattern": "https://twitter.com/%(username)s"
+    },
+    "github": {
+        "text": 'GitHub',
+        "url_pattern": "https://github.com/%(username)s"
+    },
+}
+
+def validate_external_account_field_data(field_data: ProfileFieldData) -> Optional[str]:
+    field_validator = check_dict_only(
+        [('subtype', check_required_string)],
+        [('url_pattern', check_url_pattern)],
+    )
+    error = field_validator('field_data', field_data)
+    if error:
+        return error
+
+    field_subtype = field_data.get('subtype')
+    if field_subtype not in DEFAULT_EXTERNAL_ACCOUNTS.keys():
+        if field_subtype == "custom":
+            if 'url_pattern' not in field_data.keys():
+                return _("Custom external account must define url pattern")
+        else:
+            return _("Invalid external account type")
+
+    return None

zerver/lib/types.py

@@ -24,4 +24,4 @@ UserFieldElement = Tuple[int, str, RealmUserValidator, Callable[[Any], Any], str
 
 FieldTypeData = List[Union[FieldElement, ExtendedFieldElement, UserFieldElement]]
 
-ProfileFieldData = Dict[str, Dict[str, str]]
+ProfileFieldData = Dict[str, Union[Dict[str, str], str]]

zerver/lib/validator.py

@@ -228,6 +228,21 @@ def check_url(var_name: str, val: object) -> Optional[str]:
     except ValidationError:
         return _('%s is not a URL') % (var_name,)
 
+def check_url_pattern(var_name: str, val: object) -> Optional[str]:
+    error = check_string(var_name, val)
+    if error:
+        return error
+    val = cast(str, val)
+
+    if val.count('%(username)s') != 1:
+        return _('username should appear exactly once in pattern.')
+    url_val = val.replace('%(username)s', 'username')
+
+    error = check_url(var_name, url_val)
+    if error:
+        return error
+    return None
+
 def validate_choice_field_data(field_data: ProfileFieldData) -> Optional[str]:
     """
     This function is used to validate the data sent to the server while

zerver/migrations/0234_add_external_account_custom_profile_field.py

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+# Generated by Django 1.11.20 on 2019-05-30 08:18
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('zerver', '0233_userprofile_avatar_hash'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='customprofilefield',
+            name='field_type',
+            field=models.PositiveSmallIntegerField(choices=[(1, 'Short text'), (2, 'Long text'), (4, 'Date picker'), (5, 'Link'), (7, 'External account'), (3, 'List of options'), (6, 'Person picker')], default=1),
+        ),
+    ]

zerver/models.py

@@ -2613,6 +2613,7 @@ class CustomProfileField(models.Model):
     DATE = 4
     URL = 5
     USER = 6
+    EXTERNAL_ACCOUNT = 7
 
     # These are the fields whose validators require more than var_name
     # and value argument. i.e. CHOICE require field_data, USER require
@@ -2637,6 +2638,7 @@ class CustomProfileField(models.Model):
         (LONG_TEXT, str(_('Long text')), check_long_string, str, "LONG_TEXT"),
         (DATE, str(_('Date picker')), check_date, str, "DATE"),
         (URL, str(_('Link')), check_url, str, "URL"),
+        (EXTERNAL_ACCOUNT, str(_('External account')), check_short_string, str, "EXTERNAL_ACCOUNT"),
     ]  # type: FieldTypeData
 
     ALL_FIELD_TYPES = FIELD_TYPE_DATA + CHOICE_FIELD_TYPE_DATA + USER_FIELD_TYPE_DATA

zerver/tests/test_custom_profile_data.py

@@ -141,6 +141,103 @@ class CustomProfileFieldTest(ZulipTestCase):
         result = self.client_post("/json/realm/profile_fields", info=data)
         self.assert_json_success(result)
 
+    def test_create_external_account_field(self) -> None:
+        self.login(self.example_email("iago"))
+        realm = get_realm('zulip')
+        data = {}  # type: Dict[str, Union[str, int, Dict[str, str]]]
+        data["name"] = "Twitter"
+        data["field_type"] = CustomProfileField.EXTERNAL_ACCOUNT
+
+        data['field_data'] = 'invalid'
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, "Bad value for 'field_data': invalid")
+
+        data['field_data'] = ujson.dumps({})
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, "subtype key is missing from field_data")
+
+        data["field_data"] = ujson.dumps({
+            'subtype': ''
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, 'field_data["subtype"] cannot be blank.')
+
+        data["field_data"] = ujson.dumps({
+            'subtype': '123'
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, 'Invalid external account type')
+
+        non_default_external_account = 'linkedin'
+        data["field_data"] = ujson.dumps({
+            'subtype': non_default_external_account
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, 'Invalid external account type')
+
+        data["field_data"] = ujson.dumps({
+            'subtype': 'twitter'
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_success(result)
+
+        twitter_field = CustomProfileField.objects.get(name="Twitter", realm=realm)
+        self.assertEqual(twitter_field.field_type, CustomProfileField.EXTERNAL_ACCOUNT)
+        self.assertEqual(twitter_field.name, "Twitter")
+        self.assertEqual(ujson.loads(twitter_field.field_data)['subtype'], 'twitter')
+
+        data['name'] = 'Reddit'
+        data["field_data"] = ujson.dumps({
+            'subtype': 'custom'
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, 'Custom external account must define url pattern')
+
+        data["field_data"] = ujson.dumps({
+            'subtype': 'custom',
+            'url_pattern': 123,
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, 'field_data["url_pattern"] is not a string')
+
+        data["field_data"] = ujson.dumps({
+            'subtype': 'custom',
+            'url_pattern': 'invalid',
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, 'username should appear exactly once in pattern.')
+
+        data["field_data"] = ujson.dumps({
+            'subtype': 'custom',
+            'url_pattern': 'https://www.reddit.com/%(username)s/user/%(username)s',
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, 'username should appear exactly once in pattern.')
+
+        data["field_data"] = ujson.dumps({
+            'subtype': 'custom',
+            'url_pattern': 'reddit.com/%(username)s',
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, 'field_data["url_pattern"] is not a URL')
+
+        data["field_data"] = ujson.dumps({
+            'subtype': 'custom',
+            'url_pattern': 'https://www.reddit.com/user/%(username)s',
+        })
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_success(result)
+
+        custom_field = CustomProfileField.objects.get(name="Reddit", realm=realm)
+        self.assertEqual(custom_field.field_type, CustomProfileField.EXTERNAL_ACCOUNT)
+        self.assertEqual(custom_field.name, "Reddit")
+        field_data = ujson.loads(custom_field.field_data)
+        self.assertEqual(field_data['subtype'], 'custom')
+        self.assertEqual(field_data['url_pattern'], 'https://www.reddit.com/user/%(username)s')
+
+        result = self.client_post("/json/realm/profile_fields", info=data)
+        self.assert_json_error(result, "A field with that name already exists.")
+
     def test_not_realm_admin(self) -> None:
         self.login(self.example_email("hamlet"))
         result = self.client_post("/json/realm/profile_fields")
@@ -416,6 +513,7 @@ class CustomProfileFieldTest(ZulipTestCase):
             ('Birthday', '1909-3-5'),
             ('Favorite website', 'https://zulipchat.com'),
             ('Mentor', [self.example_user("cordelia").id]),
+            ('GitHub', 'zulip-mobile')
         ]
 
         data = []

zerver/tests/test_home.py

@@ -129,6 +129,7 @@ class HomeTest(ZulipTestCase):
             "realm_bot_domain",
             "realm_bots",
             "realm_create_stream_policy",
+            "realm_default_external_accounts",
             "realm_default_language",
             "realm_default_stream_groups",
             "realm_default_streams",

zerver/tests/test_users.py

@@ -416,6 +416,7 @@ class PermissionTest(ZulipTestCase):
             'Birthday': '1909-3-5',
             'Favorite website': 'https://zulipchat.com',
             'Mentor': [cordelia.id],
+            'GitHub': 'timabbott',
         }
 
         for field_name in fields:
@@ -500,7 +501,8 @@ class PermissionTest(ZulipTestCase):
             'Favorite editor': None,
             'Birthday': None,
             'Favorite website': 'https://zulip.github.io',
-            'Mentor': [hamlet.id]
+            'Mentor': [hamlet.id],
+            'GitHub': 'timabbott',
         }
         new_profile_data = []
         for field_name in fields:

zerver/views/custom_profile_fields.py

@@ -22,6 +22,7 @@ from zerver.models import (UserProfile,
                            CustomProfileField, custom_profile_fields_for_realm)
 from zerver.lib.exceptions import JsonableError
 from zerver.lib.users import validate_user_custom_profile_data
+from zerver.lib.external_accounts import validate_external_account_field_data
 
 def list_realm_custom_profile_fields(request: HttpRequest, user_profile: UserProfile) -> HttpResponse:
     fields = custom_profile_fields_for_realm(user_profile.realm_id)
@@ -50,11 +51,12 @@ def validate_custom_field_data(field_type: int,
         if len(field_data) < 1:
             raise JsonableError(_("Field must have at least one choice."))
         error = validate_choice_field_data(field_data)
+    elif field_type == CustomProfileField.EXTERNAL_ACCOUNT:
+        error = validate_external_account_field_data(field_data)
 
     if error:
         raise JsonableError(error)
 
-
 @require_realm_admin
 @has_request_variables
 def create_realm_custom_profile_field(request: HttpRequest,

zilencer/management/commands/populate_db.py

@@ -29,6 +29,7 @@ from zerver.models import CustomProfileField, DefaultStream, Message, Realm, Rea
     UserMessage, UserPresence, UserProfile, clear_database, \
     email_to_username, get_client, get_huddle, get_realm, get_stream, \
     get_system_bot, get_user, get_user_profile_by_id
+from zerver.lib.types import ProfileFieldData
 
 from scripts.lib.zulip_tools import get_or_create_dev_uuid_var_path
 
@@ -348,7 +349,7 @@ class Command(BaseCommand):
             field_data = {
                 'vim': {'text': 'Vim', 'order': '1'},
                 'emacs': {'text': 'Emacs', 'order': '2'},
-            }
+            }  # type: ProfileFieldData
             favorite_editor = try_add_realm_custom_profile_field(zulip_realm,
                                                                  "Favorite editor",
                                                                  CustomProfileField.CHOICE,
@@ -360,6 +361,12 @@ class Command(BaseCommand):
                                                                   hint="Or your personal blog's URL")
             mentor = try_add_realm_custom_profile_field(zulip_realm, "Mentor",
                                                         CustomProfileField.USER)
+            external_account_field_data = {
+                'subtype': 'github'
+            }  # type: ProfileFieldData
+            github_profile = try_add_realm_custom_profile_field(zulip_realm, "GitHub",
+                                                                CustomProfileField.EXTERNAL_ACCOUNT,
+                                                                field_data=external_account_field_data)
 
             # Fill in values for Iago and Hamlet
             hamlet = get_user("hamlet@zulip.com", zulip_realm)
@@ -371,6 +378,7 @@ class Command(BaseCommand):
                 {"id": birthday.id, "value": "2000-1-1"},
                 {"id": favorite_website.id, "value": "https://zulip.readthedocs.io/en/latest/"},
                 {"id": mentor.id, "value": [hamlet.id]},
+                {"id": github_profile.id, "value": 'zulip'},
             ])
             do_update_user_custom_profile_data(hamlet, [
                 {"id": phone_number.id, "value": "+0-11-23-456-7890"},
@@ -383,6 +391,7 @@ class Command(BaseCommand):
                 {"id": birthday.id, "value": "1900-1-1"},
                 {"id": favorite_website.id, "value": "https://blog.zulig.org"},
                 {"id": mentor.id, "value": [iago.id]},
+                {"id": github_profile.id, "value": 'zulipbot'},
             ])
         else:
             zulip_realm = get_realm("zulip")