Change Realm defaults to Community defaults.

Previously, we set restrict_to_domain and invite_required differently
depending on whether we were setting up a community or a corporate
realm. Setting restrict_to_domain requires validation on the domain of the
user's email, which is messy in the web realm creation flow, since we
validate the user's email before knowing whether the user intends to set up
a corporate or community realm. The simplest solution is to have the realm
creation flow impose as few restrictions as possible (community defaults),
and then worry about restrict_to_domain etc. after the user is already in.

We set the test suite to explictly use the old defaults, since several of
the tests depend on the old defaults.

This commit adds a database migration.

zerver/lib/actions.py

@@ -1944,36 +1944,21 @@ def do_change_stream_description(realm, stream_name, new_description):
                  value=new_description)
     send_event(event, stream_user_ids(stream))
 
-def get_realm_creation_defaults(org_type=None, restricted_to_domain=None, invite_required=None):
-    # type: (Optional[int], Optional[bool], Optional[bool]) -> Dict[text_type, Any]
-    if org_type is None:
-        org_type = Realm.CORPORATE
-    # not totally clear what the defaults should be if exactly one of
-    # restricted_to_domain or invite_required are set. Just doing the
-    # least complicated thing that works when both are unset.
-    if restricted_to_domain is None:
-        restricted_to_domain = (org_type == Realm.CORPORATE)
-    if invite_required is None:
-        invite_required = not (org_type == Realm.CORPORATE)
-    return {'org_type': org_type,
-            'restricted_to_domain': restricted_to_domain,
-            'invite_required': invite_required}
-
 def do_create_realm(string_id, name, restricted_to_domain=None,
                     invite_required=None, org_type=None, domain=None):
     # type: (text_type, text_type, Optional[bool], Optional[bool], Optional[int], Optional[text_type]) -> Tuple[Realm, bool]
     realm = get_realm_by_string_id(string_id)
     created = not realm
     if created:
-        realm_params = get_realm_creation_defaults(org_type=org_type,
-                                                   restricted_to_domain=restricted_to_domain,
-                                                   invite_required=invite_required)
-        org_type = realm_params['org_type']
-        restricted_to_domain = realm_params['restricted_to_domain']
-        invite_required = realm_params['invite_required']
-        realm = Realm(name=name, string_id=string_id, org_type=org_type,
-                      restricted_to_domain=restricted_to_domain, invite_required=invite_required,
-                      domain=string_id + '@acme.com')
+        kwargs = {} # type: Dict[str, Any]
+        if restricted_to_domain is not None:
+            kwargs['restricted_to_domain'] = restricted_to_domain
+        if invite_required is not None:
+            kwargs['invite_required'] = invite_required
+        if org_type is not None:
+            kwargs['org_type'] = org_type
+        realm = Realm(string_id=string_id, name=name,
+                      domain=string_id + '@acme.com', **kwargs)
         realm.save()
 
         if domain:

zerver/management/commands/create_realm.py

@@ -6,7 +6,7 @@ from typing import Any
 
 from django.conf import settings
 from django.core.management.base import BaseCommand
-from zerver.lib.actions import Realm, do_create_realm, set_default_streams, get_realm_creation_defaults
+from zerver.lib.actions import Realm, do_create_realm, set_default_streams
 from zerver.models import RealmAlias
 
 if settings.ZILENCER_ENABLED:

zerver/migrations/0038_realm_change_to_community_defaults.py

@@ -0,0 +1,29 @@
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('zerver', '0037_disallow_null_string_id'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='realm',
+            name='invite_required',
+            field=models.BooleanField(default=True),
+        ),
+        migrations.AlterField(
+            model_name='realm',
+            name='org_type',
+            field=models.PositiveSmallIntegerField(default=2),
+        ),
+        migrations.AlterField(
+            model_name='realm',
+            name='restricted_to_domain',
+            field=models.BooleanField(default=False),
+        ),
+    ]

zerver/models.py

@@ -139,8 +139,8 @@ class Realm(ModelReprMixin, models.Model):
     # structure.
     name = models.CharField(max_length=40, null=True) # type: Optional[text_type]
     string_id = models.CharField(max_length=40, unique=True) # type: text_type
-    restricted_to_domain = models.BooleanField(default=True) # type: bool
-    invite_required = models.BooleanField(default=False) # type: bool
+    restricted_to_domain = models.BooleanField(default=False) # type: bool
+    invite_required = models.BooleanField(default=True) # type: bool
     invite_by_admins_only = models.BooleanField(default=False) # type: bool
     create_stream_by_admins_only = models.BooleanField(default=False) # type: bool
     mandatory_topics = models.BooleanField(default=False) # type: bool
@@ -155,7 +155,7 @@ class Realm(ModelReprMixin, models.Model):
     # Valid org_types are {CORPORATE, COMMUNITY}
     CORPORATE = 1
     COMMUNITY = 2
-    org_type = models.PositiveSmallIntegerField(default=CORPORATE) # type: int
+    org_type = models.PositiveSmallIntegerField(default=COMMUNITY) # type: int
 
     date_created = models.DateTimeField(default=timezone.now) # type: datetime.datetime
     notifications_stream = models.ForeignKey('Stream', related_name='+', null=True, blank=True) # type: Optional[Stream]

zerver/tests/test_messages.py

@@ -52,7 +52,7 @@ from typing import Any, Optional
 class TestCrossRealmPMs(ZulipTestCase):
     def make_realm(self, domain):
         # type: (text_type) -> Realm
-        realm = Realm.objects.create(string_id=domain, domain=domain)
+        realm = Realm.objects.create(string_id=domain, domain=domain, invite_required=False)
         RealmAlias.objects.create(realm=realm, domain=domain)
         return realm
 

zerver/tests/test_signup.py

@@ -608,7 +608,6 @@ class RealmCreationTest(ZulipTestCase):
         password = "test"
         string_id = "test"
         domain = "test.com"
-        org_type = Realm.COMMUNITY
         email = "user1@test.com"
 
         # Make sure the realm does not exist
@@ -629,7 +628,7 @@ class RealmCreationTest(ZulipTestCase):
             self.assertEquals(result.status_code, 200)
 
             result = self.submit_reg_form_for_user(username, password, domain=domain,
-                                                   realm_subdomain = string_id, realm_org_type=org_type)
+                                                   realm_subdomain = string_id)
             self.assertEquals(result.status_code, 302)
 
             # Make sure the realm is created
@@ -649,32 +648,6 @@ class RealmCreationTest(ZulipTestCase):
 
             self.assertTrue(result["Location"].endswith("/"))
 
-    def test_realm_corporate_defaults(self):
-        # type: () -> None
-        username = "user1"
-        password = "test"
-        string_id = "test"
-        domain = "test.com"
-        org_type = Realm.CORPORATE
-        email = "user1@test.com"
-
-        # Make sure the realm does not exist
-        self.assertIsNone(get_realm_by_string_id(string_id))
-
-        # Create new realm with the email
-        with self.settings(OPEN_REALM_CREATION=True):
-            self.client_post('/create_realm/', {'email': email})
-            confirmation_url = self.get_confirmation_url_from_outbox(email)
-            self.client_get(confirmation_url)
-            self.submit_reg_form_for_user(username, password, domain=domain,
-                                          realm_subdomain = string_id, realm_org_type=org_type)
-
-        # Check corporate defaults were set correctly
-        realm = get_realm_by_string_id(string_id)
-        self.assertEquals(realm.org_type, Realm.CORPORATE)
-        self.assertEquals(realm.restricted_to_domain, True)
-        self.assertEquals(realm.invite_required, False)
-
 class UserSignUpTest(ZulipTestCase):
 
     def test_user_default_language(self):

zilencer/management/commands/populate_db.py

@@ -125,10 +125,14 @@ class Command(BaseCommand):
             # Create our two default realms
             # Could in theory be done via zerver.lib.actions.do_create_realm, but
             # welcome-bot (needed for do_create_realm) hasn't been created yet
-            zulip_realm = Realm.objects.create(string_id="zulip", name="Zulip Dev", domain="zulip.com")
+            zulip_realm = Realm.objects.create(
+                string_id="zulip", name="Zulip Dev", restricted_to_domain=True,
+                invite_required=False, org_type=Realm.CORPORATE, domain="zulip.com")
             RealmAlias.objects.create(realm=zulip_realm, domain="zulip.com")
             if options["test_suite"]:
-                mit_realm = Realm.objects.create(string_id="mit", name="MIT", domain="mit.edu")
+                mit_realm = Realm.objects.create(
+                    string_id="mit", name="MIT", restricted_to_domain=True,
+                    invite_required=False, org_type=Realm.CORPORATE, domain="mit.edu")
                 RealmAlias.objects.create(realm=mit_realm, domain="mit.edu")
             realms = {} # type: Dict[text_type, Realm]
             for realm in Realm.objects.all():