通過（click）=調用多個功能

Question

在從我的站點刪除用戶的上下文中，我必須進行多個數據庫調用以刪除用戶ID所在的所有表格中的用戶ID（大約10個不同的表格）。

現在，我正在使用一種我認為是骯臟的技巧，其中我在同一按鈕上有多個（click）=“ function（）”事件觸發多個功能，所有這些功能均進入我的服務層並構成數據庫。 在我的服務中，我有一個功能，可以處理要刪除並刪除用戶ID的每個表格。

HTML：

<button (click)="deleteCandidateInCompanies(Item.owner)"(click)="deleteCandidateInOrganizations(Item.owner)"

Component.ts：

 deleteCandidateInCompanies(owner: string): void {
    this._candidateService.deleteCandidateFromCompanies(id)
        .then( data => {
        console.log(data);
    }).catch( err => {
        alert('An error has occurred');
       console.log(err);
    });
}

deleteCandidateInOrganizations(owner: string): void {
    this._candidateService.deleteCandidatesFromOrganizations(id)
        .then( data => {
            console.log(data);
        }).catch( err => {
        alert('An error has occurred');
        console.log(err);
    });
}

Service.ts：

deleteCandidateFromCompanies(owner: string) {
    // Get User object
    return new Promise(async (resolve, reject) => {

        const _dynamoDB = new AWS.DynamoDB.DocumentClient();
        const getUserParams = {
            TableName: 'user-table',
            Key: {
                sub: owner
            }
        };
        const user = await _dynamoDB.get(getUserParams).promise();

        // Get all companies owned by user
        for (let i = 0; i < user.Item.companies.length; i++) {
            const companyUUID = user.Item.companies[i];
            const getCompanyParams = {
                TableName: 'company-table',
                Key: {
                    uuid: companyID
                }
            };

            const company = await _dynamoDB.get(getCompanyParams).promise();

            // Check what index owner is on
            const companyIndex = company.Item.owners.indexOf(owner);

            if (companyIndex === -1) {
                continue;
            }

            const deleteUserReferenceInCompanyParams = {
                TableName: 'company-tabel',
                Key: {uuid: user.Item.companies[i]},
                UpdateExpression: 'REMOVE owners[' + i.toString() + ']'
            };


_dynamoDB.update(deleteUserReferenceInCompanyParams, function (err, data) {
                    if (err) {
                        console.log(err);
                        reject(err);
                    } else {
                        console.log(data);
                        resolve(data);
                    }
                });
            }
    });



deleteCandidatesFromOrganizations(owner: string) {
    // Get User object
    return new Promise(async (resolve, reject) =>{
       const _dynamoDB = new AWS.DynamoDB.DocumentClient();
       const getUserParams = {
           TableName: 'user-table',
           Key: {
               sub: owner
           }
       };
       const user = await _dynamoDB.get(getUserParams).promise();

       // Get all organizations owned by user
        for (let i = 0; i < user.Item.ownerOrganization.length; i++){
            const organizationUUID = user.Item.ownerOrganization[i];
            const getOrganizationParams = {
                TableName: 'organization-table',
                Key: {
                    uuid: organizationUUID
                }
            };

            const organization = await 
_dynamoDB.get(getOrganizationParams).promise();

            // Tjekker hvilket index owner er på

            const organizationsIndex = organization.Item.owners.indexOf(owner);

            if (organizationsIndex === -1) {
                continue;
            }

            const deleteUserReferenceInOrganizationParams = {
                TableName: 'organization-table',
                Key: {uuid: user.Item.ownerOrganization[i]},
                UpdateExpression: 'REMOVE owners[' + i.toString() + ']'
            };

            // tslint:disable-next-line:typedef
            _dynamoDB.update(deleteUserReferenceInOrganizationParams, function (err, data) {
                if (err) {
                    console.log(err);
                    reject(err);
                } else {
                    console.log(data);
                    resolve(data);
                }
            });
        }
    });
}

}

當我嘗試將我的函數放在óne函數的component.ts中時，出現錯誤，將從deleteCandidateFromCompanies返回的Promies忽略。

我希望應該有一種不同的方法，將所有這些功能整合在一起，並減少代碼和數據庫調用。

Answer 1

您可以采取的一種方法是，創建一個同時扭曲兩者的函數，然后您可以使用async / await處理異步調用，例如：

async myFunctionWrapper(owner){
  await deleteCandidateInCompanies(owner);
  await deleteCandidateInOrganizations(owner);
}

然后在HTML中調用包裝器

<button (click)="myFunctionWrapper(Item.owner)" />

Answer 2

另一種方法是使用模板形式，在模板中級聯函數調用，例如

<button (click)="deleteCandidateInCompanies(item.owner); deleteCandidateInOrganizations(item.owner);">Call it</button>

其他人正在使用&&但影響是

<button (click)="deleteCandidateInCompanies(item.owner) && deleteCandidateInOrganizations(item.owner);">Call it</button>

deleteCandidateInOrganizations成功deleteCandidateInCompanies調用deleteCandidateInCompanies