Inviting unregistered users by email

cvat-core/src/api-implementation.ts

@@ -341,6 +341,28 @@ export default function implementAPI(cvat) {
         };
     };
 
+    cvat.organizations.acceptInvitation.implementation = async (
+        username,
+        firstName,
+        lastName,
+        email,
+        password,
+        userConfirmations,
+        key,
+    ) => {
+        const orgSlug = await serverProxy.organizations.acceptInvitation(
+            username,
+            firstName,
+            lastName,
+            email,
+            password,
+            userConfirmations,
+            key,
+        );
+
+        return orgSlug;
+    };
+
     cvat.webhooks.get.implementation = async (filter) => {
         checkFilter(filter, {
             page: isInteger,

cvat-core/src/api.ts

@@ -270,6 +270,19 @@ function build() {
                 const result = await PluginRegistry.apiWrapper(cvat.organizations.deactivate);
                 return result;
             },
+            async acceptInvitation(username, firstName, lastName, email, password, userConfirmations, key) {
+                const result = await PluginRegistry.apiWrapper(
+                    cvat.organizations.acceptInvitation,
+                    username,
+                    firstName,
+                    lastName,
+                    email,
+                    password,
+                    userConfirmations,
+                    key,
+                );
+                return result;
+            },
         },
         webhooks: {
             async get(filter: any) {

cvat-core/src/organization.ts

@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MIT
 
-import { SerializedOrganization, SerializedOrganizationContact } from './server-response-types';
+import { SerializedOrganization, SerializedOrganizationContact, SerializedUser } from './server-response-types';
 import { checkObjectType, isEnum } from './common';
 import config from './config';
 import { MembershipRole } from './enums';
@@ -12,15 +12,82 @@ import PluginRegistry from './plugins';
 import serverProxy from './server-proxy';
 import User from './user';
 
-interface Membership {
-    user: User;
+interface SerializedInvitationData {
+    created_date: string;
+    key: string;
+    owner: SerializedUser;
+}
+
+interface SerializedMembershipData {
+    id: number;
+    user: SerializedUser;
     is_active: boolean;
     joined_date: string;
     role: MembershipRole;
-    invitation: {
-        created_date: string;
-        owner: User;
-    } | null;
+    invitation: SerializedInvitationData | null;
+}
+
+export class Invitation {
+    #createdDate: string;
+    #owner: User;
+    #key: string;
+
+    constructor(initialData: SerializedInvitationData) {
+        this.#createdDate = initialData.created_date;
+        this.#owner = new User(initialData.owner);
+        this.#key = initialData.key;
+    }
+
+    get owner(): User {
+        return this.#owner;
+    }
+
+    get createdDate(): string {
+        return this.#createdDate;
+    }
+
+    get key(): string {
+        return this.#key;
+    }
+}
+
+export class Membership {
+    #id: number;
+    #user: User;
+    #isActive: boolean;
+    #joinedDate: string;
+    #role: MembershipRole;
+    #invitation: Invitation | null;
+
+    constructor(initialData: SerializedMembershipData) {
+        this.#id = initialData.id;
+        this.#user = new User(initialData.user);
+        this.#isActive = initialData.is_active;
+        this.#joinedDate = initialData.joined_date;
+        this.#role = initialData.role;
+        this.#invitation = initialData.invitation ? new Invitation(initialData.invitation) : null;
+    }
+
+    get id(): number {
+        return this.#id;
+    }
+
+    get user(): User {
+        return this.#user;
+    }
+
+    get isActive(): boolean {
+        return this.#isActive;
+    }
+    get joinedDate(): string {
+        return this.#joinedDate;
+    }
+    get role(): MembershipRole {
+        return this.#role;
+    }
+    get invitation(): Invitation {
+        return this.#invitation;
+    }
 }
 
 export default class Organization {
@@ -193,6 +260,15 @@ export default class Organization {
         );
         return result;
     }
+
+    public async resendInvitation(key: string): Promise<void> {
+        const result = await PluginRegistry.apiWrapper.call(
+            this,
+            Organization.prototype.resendInvitation,
+            key,
+        );
+        return result;
+    }
 }
 
 Object.defineProperties(Organization.prototype.save, {
@@ -234,27 +310,12 @@ Object.defineProperties(Organization.prototype.members, {
             checkObjectType('pageSize', pageSize, 'number');
 
             const result = await serverProxy.organizations.members(orgSlug, page, pageSize);
-            await Promise.all(
-                result.results.map((membership) => {
-                    const { invitation } = membership;
-                    membership.user = new User(membership.user);
-                    if (invitation) {
-                        return serverProxy.organizations
-                            .invitation(invitation)
-                            .then((invitationData) => {
-                                membership.invitation = invitationData;
-                            })
-                            .catch(() => {
-                                membership.invitation = null;
-                            });
-                    }
+            const memeberships = result.results.map((rawMembership: SerializedMembershipData) => new Membership(
+                rawMembership,
+            ));
 
-                    return Promise.resolve();
-                }),
-            );
-
-            result.results.count = result.count;
-            return result.results;
+            memeberships.count = result.count;
+            return memeberships;
         },
     },
 });
@@ -347,3 +408,16 @@ Object.defineProperties(Organization.prototype.leave, {
         },
     },
 });
+
+Object.defineProperties(Organization.prototype.resendInvitation, {
+    implementation: {
+        writable: false,
+        enumerable: false,
+        value: async function implementation(key: string) {
+            checkObjectType('key', key, 'string');
+            if (typeof this.id === 'number') {
+                await serverProxy.organizations.resendInvitation(key);
+            }
+        },
+    },
+});

cvat-core/src/server-proxy.ts

@@ -454,6 +454,33 @@ async function resetPassword(newPassword1: string, newPassword2: string, uid: st
     }
 }
 
+async function acceptOrganizationInvitation(
+    username: string,
+    firstName: string,
+    lastName: string,
+    email: string,
+    password: string,
+    confirmations: Record<string, string>,
+    key: string,
+): Promise<SerializedRegister> {
+    let response = null;
+
+    try {
+        response = await Axios.post(`${config.backendAPI}/invitations/${key}/accept`, {
+            username,
+            first_name: firstName,
+            last_name: lastName,
+            password1: password,
+            password2: password,
+            confirmations,
+        });
+    } catch (errorData) {
+        throw generateError(errorData);
+    }
+
+    return response.data;
+}
+
 async function getSelf(): Promise<SerializedUser> {
     const { backendAPI } = config;
 
@@ -2059,6 +2086,15 @@ async function inviteOrganizationMembers(orgId, data) {
     }
 }
 
+async function resendOrganizationInvitation(key) {
+    const { backendAPI } = config;
+    try {
+        await Axios.post(`${backendAPI}/invitations/${key}/resend`);
+    } catch (errorData) {
+        throw generateError(errorData);
+    }
+}
+
 async function updateOrganizationMembership(membershipId, data) {
     const { backendAPI } = config;
     let response = null;
@@ -2481,8 +2517,10 @@ export default Object.freeze({
         invitation: getMembershipInvitation,
         delete: deleteOrganization,
         invite: inviteOrganizationMembers,
+        resendInvitation: resendOrganizationInvitation,
         updateMembership: updateOrganizationMembership,
         deleteMembership: deleteOrganizationMembership,
+        acceptInvitation: acceptOrganizationInvitation,
     }),
 
     webhooks: Object.freeze({

cvat-core/src/server-response-types.ts

@@ -50,6 +50,7 @@ export interface SerializedUser {
     is_active?: boolean;
     last_login?: string;
     date_joined?: string;
+    email_verification_required: boolean;
 }
 
 export interface SerializedProject {

cvat-core/src/user.ts

@@ -3,36 +3,23 @@
 //
 // SPDX-License-Identifier: MIT
 
-interface RawUserData {
-    id: number;
-    username: string;
-    email: string;
-    first_name: string;
-    last_name: string;
-    groups: string[];
-    last_login: string;
-    date_joined: string;
-    is_staff: boolean;
-    is_superuser: boolean;
-    is_active: boolean;
-    email_verification_required: boolean;
-}
+import { SerializedUser } from './server-response-types';
 
 export default class User {
     public readonly id: number;
     public readonly username: string;
     public readonly email: string;
     public readonly firstName: string;
     public readonly lastName: string;
-    public readonly groups: string[];
+    public readonly groups: ('user' | 'business' | 'admin')[];
     public readonly lastLogin: string;
     public readonly dateJoined: string;
     public readonly isStaff: boolean;
     public readonly isSuperuser: boolean;
     public readonly isActive: boolean;
     public readonly isVerified: boolean;
 
-    constructor(initialData: RawUserData) {
+    constructor(initialData: SerializedUser) {
         const data = {
             id: null,
             username: null,
@@ -97,7 +84,7 @@ export default class User {
         );
     }
 
-    serialize(): RawUserData {
+    serialize(): Partial<SerializedUser> {
         return {
             id: this.id,
             username: this.username,