invite-team-members

app/notify_client/models.py

@@ -27,6 +27,7 @@ class User(UserMixin):
         self.max_failed_login_count = max_failed_login_count
         self.platform_admin = fields.get('platform_admin')
         self.current_session_id = fields.get('current_session_id')
+        self.organisations = fields.get('organisations', [])
 
     def get_id(self):
         return self.id
@@ -155,6 +156,7 @@ class User(UserMixin):
             "state": self.state,
             "failed_login_count": self.failed_login_count,
             "permissions": [x for x in self._permissions],
+            "organisations": self.organisations,
             "current_session_id": self.current_session_id
         }
         if hasattr(self, '_password'):
@@ -164,6 +166,14 @@ class User(UserMixin):
     def set_password(self, pwd):
         self._password = pwd
 
+    @property
+    def organisations(self):
+        return self._organisations
+
+    @organisations.setter
+    def organisations(self, organisations):
+        self._organisations = organisations
+
 
 class InvitedUser(object):
 
@@ -217,6 +227,38 @@ class InvitedUser(object):
         return data
 
 
+class InvitedOrgUser(object):
+
+    def __init__(self, id, organisation, invited_by, email_address, status, created_at):
+        self.id = id
+        self.organisation = str(organisation)
+        self.invited_by = invited_by
+        self.email_address = email_address
+        self.status = status
+        self.created_at = created_at
+
+    def __eq__(self, other):
+        return ((self.id,
+                self.organisation,
+                self.invited_by,
+                self.email_address,
+                self.status) == (other.id,
+                other.organisation,
+                other.invited_by,
+                other.email_address,
+                other.status))
+
+    def serialize(self, permissions_as_string=False):
+        data = {'id': self.id,
+                'organisation': self.organisation,
+                'invited_by': self.invited_by,
+                'email_address': self.email_address,
+                'status': self.status,
+                'created_at': str(self.created_at)
+                }
+        return data
+
+
 class AnonymousUser(AnonymousUserMixin):
     # set the anonymous user so that if a new browser hits us we don't error http://stackoverflow.com/a/19275188
     def logged_in_elsewhere(self):

app/notify_client/org_invite_api_client.py

@@ -0,0 +1,52 @@
+from app.notify_client import _attach_current_user, NotifyAdminAPIClient
+from app.notify_client.models import InvitedOrgUser
+
+
+class OrgInviteApiClient(NotifyAdminAPIClient):
+    def __init__(self):
+        super().__init__("a" * 73, "b")
+
+    def init_app(self, app):
+        self.base_url = app.config['API_HOST_NAME']
+        self.admin_url = app.config['ADMIN_BASE_URL']
+        self.service_id = app.config['ADMIN_CLIENT_USER_NAME']
+        self.api_key = app.config['ADMIN_CLIENT_SECRET']
+
+    def create_invite(self, invite_from_id, org_id, email_address):
+        data = {
+            'email_address': email_address,
+            'invited_by': invite_from_id,
+            'invite_link_host': self.admin_url,
+        }
+        data = _attach_current_user(data)
+        resp = self.post(url='/organisation/{}/invite'.format(org_id), data=data)
+        return InvitedOrgUser(**resp['data'])
+
+    def get_invites_for_organisation(self, org_id):
+        endpoint = '/organisation/{}/invite'.format(org_id)
+        resp = self.get(endpoint)
+        invites = resp['data']
+        invited_users = self._get_invited_org_users(invites)
+        return invited_users
+
+    def check_token(self, token):
+        resp = self.get(url='/organisation-invitation/{}'.format(token))
+        return InvitedOrgUser(**resp['data'])
+
+    def cancel_invited_user(self, org_id, invited_user_id):
+        data = {'status': 'cancelled'}
+        data = _attach_current_user(data)
+        self.post(url='/organisation/{0}/invite/{1}'.format(org_id, invited_user_id),
+                  data=data)
+
+    def accept_invite(self, org_id, invited_user_id):
+        data = {'status': 'accepted'}
+        self.post(url='/organisation/{0}/invite/{1}'.format(org_id, invited_user_id),
+                  data=data)
+
+    def _get_invited_org_users(self, invites):
+        invited_users = []
+        for invite in invites:
+            invited_user = InvitedOrgUser(**invite)
+            invited_users.append(invited_user)
+        return invited_users

app/notify_client/organisations_api_client.py

@@ -1,4 +1,4 @@
-from app.notify_client import NotifyAdminAPIClient
+from app.notify_client import _attach_current_user, NotifyAdminAPIClient
 
 
 class OrganisationsClient(NotifyAdminAPIClient):
@@ -43,3 +43,10 @@ class OrganisationsClient(NotifyAdminAPIClient):
 
     def get_organisation_services(self, org_id):
         return self.get(url="/organisations/{}/services".format(org_id))
+
+    def remove_user_from_organisation(self, org_id, user_id):
+        endpoint = '/organisations/{}/users/{}'.format(
+            org_id=org_id,
+            user_id=user_id)
+        data = _attach_current_user({})
+        return self.delete(endpoint, data)

app/notify_client/user_api_client.py

@@ -131,12 +131,21 @@ class UserApiClient(NotifyAdminAPIClient):
         resp = self.get(endpoint)
         return [User(data) for data in resp['data']]
 
+    def get_users_for_organisation(self, org_id):
+        endpoint = '/organisations/{}/users'.format(org_id)
+        resp = self.get(endpoint)
+        return [User(data) for data in resp['data']]
+
     def add_user_to_service(self, service_id, user_id, permissions):
         endpoint = '/service/{}/users/{}'.format(service_id, user_id)
         data = [{'permission': x} for x in permissions]
         resp = self.post(endpoint, data=data)
         return User(resp['data'], max_failed_login_count=self.max_failed_login_count)
 
+    def add_user_to_organisation(self, org_id, user_id):
+        resp = self.post('/organisations/{}/users/{}'.format(org_id, user_id), data={})
+        return User(resp['data'], max_failed_login_count=self.max_failed_login_count)
+
     def set_user_permissions(self, user_id, service_id, permissions):
         data = [{'permission': x} for x in permissions]
         endpoint = '/user/{}/service/{}/permission'.format(user_id, service_id)
@@ -147,10 +156,10 @@ class UserApiClient(NotifyAdminAPIClient):
         data = {'email': email_address}
         self.post(endpoint, data=data)
 
-    def is_email_unique(self, email_address):
+    def is_email_already_in_use(self, email_address):
         if self.get_user_by_email_or_none(email_address):
-            return False
-        return True
+            return True
+        return False
 
     def activate_user(self, user):
         if user.state == 'pending':