async getIterations(
        projectId: string,
        iterations: [string, string][]
    ): Promise<IIteration[]> {
        const client = getClient(WorkRestClient);

        const result = await Promise.all(
            iterations.map(([teamId, iterationId]) =>
                client
                    .getTeamIteration(
                        {
                            project: "",
                            projectId,
                            team: "",
                            teamId
                        },
                        iterationId
                    )
                    .then(
                        x =>
                            ({
                                id: x.id,
                                name: x.name
                            } as IIteration)
                    )
                    .catch(() => null)
            )
        );

        return result.filter(x => x !== null) as IIteration[];
    }

 public async getAllTeams(projectId: string): Promise<ITeam[]> {
     const client = getClient(CoreRestClient);
     const teams = await client.getTeams(projectId);
     return teams.map(({ id, name }) => ({
         id,
         name
     }));
 }

    async getWorkItemTypes(projectId: string): Promise<IWorkItemType[]> {
        // Get type fields
        const workClient = getClient(WorkRestClient);
        const processConfig = await workClient.getProcessConfiguration(
            projectId
        );
        const effortField = processConfig.typeFields["Effort"]!;

        const client = getClient(WorkItemTrackingRestClient);
        const workItemTypes = await client.getWorkItemTypes(projectId);

        // Merge with config
        const sessionService = Services.getService<ISessionService>(
            SessionServiceId
        );
        const configuration = await sessionService.getSettingsValue<{
            [name: string]: IWorkItemType;
        }>(projectId, FieldConfiguration);

        return workItemTypes.map(wi => {
            let estimationFieldRefName: string | undefined;

            if (
                wi.fields.some(
                    f =>
                        f.referenceName.toLocaleLowerCase() ===
                        effortField.referenceName.toLocaleLowerCase()
                )
            ) {
                // Work item type has effort field, use this
                estimationFieldRefName = effortField.referenceName;
            }

            // Check for overrides from configuration
            if (configuration && configuration[wi.name]) {
                estimationFieldRefName =
                    configuration[wi.name].estimationFieldRefName;
            }

            return {
                name: wi.name,
                estimationFieldRefName
            };
        });
    }

    async runQuery(projectId: string, queryId: string): Promise<number[]> {
        const client = getClient(WorkItemTrackingRestClient);
        const result = await client.queryById(queryId, projectId);

        if (result.workItems) {
            return result.workItems.map(x => x.id);
        } else if (result.workItemRelations) {
            return result.workItemRelations.map(x => x.target.id);
        }

        return [];
    }

    async getFields(projectId: string): Promise<IField[]> {
        const client = getClient(WorkItemTrackingRestClient);
        const fields = await client.getFields(projectId);

        const mappedFields: IField[] = fields.map(f => ({
            name: f.name,
            referenceName: f.referenceName
        }));
        mappedFields.sort((a, b) => a.name.localeCompare(b.name));

        return mappedFields;
    }

    async getQueries(projectId: string, queryIds: string[]): Promise<IQuery[]> {
        const client = getClient(WorkItemTrackingRestClient);
        const queries = await client.getQueriesBatch(
            {
                ids: queryIds,
                errorPolicy: QueryErrorPolicy.Omit,
                $expand: QueryExpand.Minimal
            },
            projectId
        );

        return queries.map(q => ({
            id: q.id,
            name: q.name
        }));
    }

    async saveEstimate(
        workItemId: number,
        estimationFieldRefName: string,
        estimate?: string | number | undefined
    ): Promise<void> {
        const client = getClient(WorkItemTrackingRestClient);

        await client.updateWorkItem(
            [
                {
                    op: "add",
                    path: `/fields/${estimationFieldRefName}`,
                    value: estimate
                }
            ],
            workItemId
        );
    }

    public async getIterationsForTeam(teamId: string): Promise<IIteration[]> {
        const projectService: IProjectPageService = await DevOps.getService<
            IProjectPageService
        >("ms.vss-tfs-web.tfs-page-data-service");
        const project = await projectService.getProject();
        if (!project) {
            throw new Error("Project is required");
        }

        const client = getClient(WorkRestClient);
        const teamIterations = await client.getTeamIterations({
            projectId: project.id,
            teamId
        } as TeamContext);

        return teamIterations.map(({ id, name }) => ({
            id,
            name
        }));
    }

    async getWorkItems(
        projectId: string,
        teamId: string,
        iterationId: string
    ): Promise<number[]> {
        const teamContext = {
            project: "",
            projectId,
            team: "",
            teamId
        };

        // Get ownership for team
        const client = getClient(WorkRestClient);
        const iterationWorkItems = await client.getIterationWorkItems(
            teamContext,
            iterationId
        );

        return iterationWorkItems.workItemRelations.map(x => x.target.id);
    }

    async getWorkItems(workItemIds: number[]): Promise<IWorkItem[]> {
        if (!workItemIds || workItemIds.length === 0) {
            return [];
        }

        // Get all work items
        const workItemTrackingClient = getClient(WorkItemTrackingRestClient);
        const workItems = await workItemTrackingClient.getWorkItemsBatch({
            ids: workItemIds,
            fields: [
                "System.Id",
                "System.Title",
                "System.WorkItemType",
                "System.TeamProject"
            ],
            $expand: 0 /* None */,
            errorPolicy: 2 /* Omit */
        } as WorkItemBatchGetRequest);

        const mappedWorkItems: IWorkItem[] = workItems.map(wi => {
            return {
                project: wi.fields["System.TeamProject"],
                id: wi.id,
                title: wi.fields["System.Title"],
                workItemType: wi.fields["System.WorkItemType"],
                description: ""
            };
        });

        // The rest of the method is getting the work item type definitions for the work items and then identifying which HTML fields
        // to use for the description. If most of the work items are in a single project this should be fast, if not it could be
        // really really slow, but this should not be the mainline scenario.

        // Aggregate all projects
        const projectById = new Map<
            string,
            { workItemTypes: Map<string, IWorkItemTypeInfo> }
        >();
        for (const workItem of mappedWorkItems) {
            if (projectById.has(workItem.project)) {
                const projectEntry = projectById.get(workItem.project)!;
                // We can just override here
                projectEntry.workItemTypes.set(workItem.workItemType, {});
            } else {
                projectById.set(workItem.project, {
                    workItemTypes: new Map<string, IWorkItemTypeInfo>([
                        [workItem.workItemType, {}]
                    ])
                });
            }
        }

        const coreClient = getClient(CoreRestClient);
        const processClient = getClient(WorkItemTrackingProcessRestClient);

        await Promise.all(
            Array.from(projectById.entries()).map(
                async ([projectName, projectInfo]) => {
                    // Get id for project
                    // Unfortunately, the project properties API only accepts projectId and not name, so make this roundtrip here.
                    const project = await coreClient.getProject(projectName);

                    // Get work item types and their configuration
                    const currentProjectWorkItemTypes = await this.getWorkItemTypes(
                        project.id
                    );

                    const witEstimationFieldRefNameMapping: {
                        [workItemTypeName: string]: string | undefined;
                    } = {};
                    currentProjectWorkItemTypes.forEach(workItemType => {
                        witEstimationFieldRefNameMapping[workItemType.name] =
                            workItemType.estimationFieldRefName;
                    });

                    // Get process type id
                    const properties = await coreClient.getProjectProperties(
                        project.id,
                        ["System.ProcessTemplateType"]
                    );
                    const processTypeId = properties[0].value;

                    const workItemTypes = await processClient.getProcessWorkItemTypes(
                        processTypeId
                    );

                    // Map of friendly work item name (e.g. Bug) to reference name inherited customization
                    const witNameToRefNameMapping: {
                        [name: string]: string;
                    } = {};
                    workItemTypes.forEach(x => {
                        witNameToRefNameMapping[x.name] = x.referenceName;
                    });

                    // Get work item type definitions
                    await Promise.all(
                        Array.from(projectInfo.workItemTypes.keys()).map(
                            async workItemTypeName => {
                                const workItemType = await processClient.getProcessWorkItemType(
                                    processTypeId,
//.........这里部分代码省略.........