Inviting unregistered users by email

cvat-core/src/api-implementation.ts

@@ -106,6 +106,28 @@ export default function implementAPI(cvat) {
         await serverProxy.server.resetPassword(newPassword1, newPassword2, uid, token);
     };
 
+    cvat.server.acceptInvitation.implementation = async (
+        username,
+        firstName,
+        lastName,
+        email,
+        password,
+        userConfirmations,
+        key,
+    ) => {
+        const orgSlug = await serverProxy.server.acceptInvitation(
+            username,
+            firstName,
+            lastName,
+            email,
+            password,
+            userConfirmations,
+            key,
+        );
+
+        return orgSlug;
+    };
+
     cvat.server.authorized.implementation = async () => {
         const result = await serverProxy.server.authorized();
         return result;

cvat-core/src/api.ts

@@ -96,6 +96,19 @@ function build() {
                 );
                 return result;
             },
+            async acceptInvitation(username, firstName, lastName, email, password, userConfirmations, key) {
+                const result = await PluginRegistry.apiWrapper(
+                    cvat.server.acceptInvitation,
+                    username,
+                    firstName,
+                    lastName,
+                    email,
+                    password,
+                    userConfirmations,
+                    key,
+                );
+                return result;
+            },
             async authorized() {
                 const result = await PluginRegistry.apiWrapper(cvat.server.authorized);
                 return result;

cvat-core/src/organization.ts

@@ -10,17 +10,84 @@ import { MembershipRole } from './enums';
 import { ArgumentError, DataError } from './exceptions';
 import PluginRegistry from './plugins';
 import serverProxy from './server-proxy';
-import User from './user';
+import User, { RawUserData } from './user';
 
-interface Membership {
-    user: User;
+interface SerializedInvitationData {
+    created_date: string;
+    key: string;
+    owner: RawUserData;
+}
+
+interface SerializedMembershipData {
+    id: number;
+    user: RawUserData;
     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,24 @@ 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;
+    }
+
+    public async deleteInvitation(key: string): Promise<void> {
+        const result = await PluginRegistry.apiWrapper.call(
+            this,
+            Organization.prototype.deleteInvitation,
+            key,
+        );
+        return result;
+    }
 }
 
 Object.defineProperties(Organization.prototype.save, {
@@ -234,24 +319,9 @@ 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;
-                            });
-                    }
-
-                    return Promise.resolve();
-                }),
-            );
+            result.results = result.results.map((rawMembership: SerializedMembershipData) => new Membership(
+                rawMembership,
+            ));
 
             result.results.count = result.count;
             return result.results;
@@ -347,3 +417,29 @@ 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);
+            }
+        },
+    },
+});
+
+Object.defineProperties(Organization.prototype.deleteInvitation, {
+    implementation: {
+        writable: false,
+        enumerable: false,
+        value: async function implementation(key: string) {
+            checkObjectType('key', key, 'string');
+            if (typeof this.id === 'number') {
+                await serverProxy.organizations.deleteInvitation(key);
+            }
+        },
+    },
+});

cvat-core/src/server-proxy.ts

@@ -454,6 +454,33 @@ async function resetPassword(newPassword1: string, newPassword2: string, uid: st
     }
 }
 
+async function acceptInvitation(
+    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,24 @@ 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 deleteOrganizationInvitation(key) {
+    const { backendAPI } = config;
+    try {
+        await Axios.delete(`${backendAPI}/invitations/${key}`);
+    } catch (errorData) {
+        throw generateError(errorData);
+    }
+}
+
 async function updateOrganizationMembership(membershipId, data) {
     const { backendAPI } = config;
     let response = null;
@@ -2365,6 +2410,7 @@ export default Object.freeze({
         request: serverRequest,
         userAgreements,
         installedApps,
+        acceptInvitation,
     }),
 
     projects: Object.freeze({
@@ -2481,6 +2527,8 @@ export default Object.freeze({
         invitation: getMembershipInvitation,
         delete: deleteOrganization,
         invite: inviteOrganizationMembers,
+        resendInvitation: resendOrganizationInvitation,
+        deleteInvitation: deleteOrganizationInvitation,
         updateMembership: updateOrganizationMembership,
         deleteMembership: deleteOrganizationMembership,
     }),

cvat-core/src/user.ts

@@ -3,7 +3,7 @@
 //
 // SPDX-License-Identifier: MIT
 
-interface RawUserData {
+export interface RawUserData {
     id: number;
     username: string;
     email: string;