public async getReleases()

in api/ReleaseApi.ts [2926:3006]
73 lines of code
5 McCabe index (conditional complexity)

    public async getReleases(
        project?: string,
        definitionId?: number,
        definitionEnvironmentId?: number,
        searchText?: string,
        createdBy?: string,
        statusFilter?: ReleaseInterfaces.ReleaseStatus,
        environmentStatusFilter?: number,
        minCreatedTime?: Date,
        maxCreatedTime?: Date,
        queryOrder?: ReleaseInterfaces.ReleaseQueryOrder,
        top?: number,
        continuationToken?: number,
        expand?: ReleaseInterfaces.ReleaseExpands,
        artifactTypeId?: string,
        sourceId?: string,
        artifactVersionId?: string,
        sourceBranchFilter?: string,
        isDeleted?: boolean,
        tagFilter?: string[],
        propertyFilters?: string[],
        releaseIdFilter?: number[],
        path?: string
        ): Promise<ReleaseInterfaces.Release[]> {

        return new Promise<ReleaseInterfaces.Release[]>(async (resolve, reject) => {
            let routeValues: any = {
                project: project
            };

            let queryValues: any = {
                definitionId: definitionId,
                definitionEnvironmentId: definitionEnvironmentId,
                searchText: searchText,
                createdBy: createdBy,
                statusFilter: statusFilter,
                environmentStatusFilter: environmentStatusFilter,
                minCreatedTime: minCreatedTime,
                maxCreatedTime: maxCreatedTime,
                queryOrder: queryOrder,
                '$top': top,
                continuationToken: continuationToken,
                '$expand': expand,
                artifactTypeId: artifactTypeId,
                sourceId: sourceId,
                artifactVersionId: artifactVersionId,
                sourceBranchFilter: sourceBranchFilter,
                isDeleted: isDeleted,
                tagFilter: tagFilter && tagFilter.join(","),
                propertyFilters: propertyFilters && propertyFilters.join(","),
                releaseIdFilter: releaseIdFilter && releaseIdFilter.join(","),
                path: path,
            };
            
            try {
                let verData: vsom.ClientVersioningData = await this.vsoClient.getVersioningData(
                    "6.1-preview.8",
                    "Release",
                    "a166fde7-27ad-408e-ba75-703c2cc9d500",
                    routeValues,
                    queryValues);

                let url: string = verData.requestUrl!;
                let options: restm.IRequestOptions = this.createRequestOptions('application/json', 
                                                                                verData.apiVersion);

                let res: restm.IRestResponse<ReleaseInterfaces.Release[]>;
                res = await this.rest.get<ReleaseInterfaces.Release[]>(url, options);

                let ret = this.formatResponse(res.result,
                                              ReleaseInterfaces.TypeInfo.Release,
                                              true);

                resolve(ret);
                
            }
            catch (err) {
                reject(err);
            }
        });
    }