_parseGroupByResult()

in lib/protocol/decoder.js [471:600]

• 130 lines of code
• 10 McCabe index (conditional complexity)

    _parseGroupByResult(groupByType, groupByResultBody) {
        switch (groupByType) {
            case tsSearchProtos.GroupByType.GROUP_BY_FIELD: {
                let groupByFieldResult = tsSearchProtos.GroupByFieldResult.decode(groupByResultBody);
                let resultItems = [];
                TableStore.util.arrayEach(groupByFieldResult.groupByFieldResultItems, function (item) {
                    let itemResult = {
                        key: item.key,
                        rowCount: item.rowCount,
                    };
                    TableStore.decoder._parseSubAggAndGroupByResult(itemResult, item);
                    resultItems.push(itemResult);
                });
                return {
                    items: resultItems,
                };
            }
            case tsSearchProtos.GroupByType.GROUP_BY_RANGE: {
                let groupByRangeResult = tsSearchProtos.GroupByRangeResult.decode(groupByResultBody);
                let resultItems = [];
                TableStore.util.arrayEach(groupByRangeResult.groupByRangeResultItems, function (item) {
                    let itemResult = {
                        from: item.from,
                        to: item.to,
                        rowCount: item.rowCount,
                    };
                    TableStore.decoder._parseSubAggAndGroupByResult(itemResult, item);
                    resultItems.push(itemResult);
                });
                return {
                    items: resultItems,
                };
            }
            case tsSearchProtos.GroupByType.GROUP_BY_FILTER: {
                let groupByFilterResult = tsSearchProtos.GroupByFilterResult.decode(groupByResultBody);
                let resultItems = [];
                TableStore.util.arrayEach(groupByFilterResult.groupByFilterResultItems, function (item) {
                    let itemResult = {
                        rowCount: item.rowCount,
                    };
                    TableStore.decoder._parseSubAggAndGroupByResult(itemResult, item);
                    resultItems.push(itemResult);
                });
                return {
                    items: resultItems,
                };
            }
            case tsSearchProtos.GroupByType.GROUP_BY_GEO_DISTANCE: {
                let groupByGeoDistanceResult = tsSearchProtos.GroupByGeoDistanceResult.decode(groupByResultBody);
                let resultItems = [];
                TableStore.util.arrayEach(groupByGeoDistanceResult.groupByGeoDistanceResultItems, function (item) {
                    let itemResult = {
                        from: item.from,
                        to: item.to,
                        rowCount: item.rowCount,
                    };
                    TableStore.decoder._parseSubAggAndGroupByResult(itemResult, item);
                    resultItems.push(itemResult);
                });
                return {
                    items: resultItems,
                };
            }
            case tsSearchProtos.GroupByType.GROUP_BY_HISTOGRAM: {
                let groupByHistogramResult = tsSearchProtos.GroupByHistogramResult.decode(groupByResultBody);
                let resultItems = [];
                TableStore.util.arrayEach(groupByHistogramResult.groupByHistogramItems, function (item) {
                    let itemResult = {
                        key: TableStore.decoder._parseSearchVariant(item.key),
                        value: item.value,
                    };
                    TableStore.decoder._parseSubAggAndGroupByResult(itemResult, item);
                    resultItems.push(itemResult);
                });
                return {
                    items: resultItems,
                };
            }
            case tsSearchProtos.GroupByType.GROUP_BY_DATE_HISTOGRAM: {
                let groupByDateHistogramResult = tsSearchProtos.GroupByDateHistogramResult.decode(groupByResultBody);
                let resultItems = [];
                TableStore.util.arrayEach(groupByDateHistogramResult.groupByDateHistogramItems, function (item) {
                    let itemResult = {
                        timeStamp: item.timestamp,
                        rowCount: item.rowCount,
                    };
                    TableStore.decoder._parseSubAggAndGroupByResult(itemResult, item);
                    resultItems.push(itemResult);
                });
                return {
                    items: resultItems,
                };
            }
            case tsSearchProtos.GroupByType.GROUP_BY_GEO_GRID: {
                let groupByGeoGridResult = tsSearchProtos.GroupByGeoGridResult.decode(groupByResultBody);
                let resultItems = [];
                TableStore.util.arrayEach(groupByGeoGridResult.groupByGeoGridResultItems, function (item) {
                    let itemResult = {
                        key: item.key,
                        rowCount: item.rowCount,
                        geoGrid: item.geoGrid,
                    };
                    TableStore.decoder._parseSubAggAndGroupByResult(itemResult, item);
                    resultItems.push(itemResult);
                });
                return {
                    items: resultItems,
                };
            }
            case tsSearchProtos.GroupByType.GROUP_BY_COMPOSITE: {
                let groupByCompositeResult = tsSearchProtos.GroupByCompositeResult.decode(groupByResultBody);
                let resultItems = [];
                TableStore.util.arrayEach(groupByCompositeResult.groupByCompositeResultItems, function (item) {
                    let itemResult = {
                        keys: item.keys,
                        rowCount: item.rowCount,
                    };
                    TableStore.decoder._parseSubAggAndGroupByResult(itemResult, item);
                    resultItems.push(itemResult);
                });
                return {
                    sourceNames: groupByCompositeResult.sourceGroupByNames,
                    nextToken: groupByCompositeResult.nextToken || null,
                    items: resultItems,
                };
            }
            default:
                throw new Error("not exist groupByType: " + groupByType);
        }
    },