从（单击）调用多个函数=

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);
                }
            });
        }
    });
}

}

当我尝试将我的函数放在 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

成功后调用

从（单击）调用多个函数=

Calling multiple functions from (click)=

javascript

click

typescript

angular