getReads()

in client/client/dataServices/bam/bam-data-service.js [33:163]

• 92 lines of code
• 24 McCabe index (conditional complexity)

    getReads(parameters, showClipping, filter) {
        const self = this;
        const getReadsFn = function(singleParameters) {
            const {side, ...props} = singleParameters;
            let loadDataFn = null;
            switch (side) {
                case 'center': {
                    loadDataFn = ::self.getFullCenter;
                }
                    break;
                case 'left': {
                    loadDataFn = ::self.getFullLeft;
                }
                    break;
                case 'right': {
                    loadDataFn = ::self.getFullRight;
                }
                    break;
                default: {
                    return Promise.resolve();
                }
            }
            if (loadDataFn) {
                const resolveFn = function(resolve) {
                    const catchFn = function() {
                        resolve({});
                    };
                    const thenFn = function(data) {
                        resolve(data);
                    };
                    loadDataFn(props, showClipping, filter).catch(catchFn).then(thenFn);
                };
                return new Promise(resolveFn);
            }
        };
        if (parameters instanceof Array) {
            const promises = [];
            for (let i = 0; i < parameters.length; i++) {
                promises.push(getReadsFn(parameters[i]));
            }
            return new Promise((resolve) => {
                Promise.all(promises).then(values => {
                    let result = {
                        baseCoverage: [],
                        blocks: [],
                        downsampleCoverage: [],
                        chromosome: null,
                        endIndex: null,
                        id: null,
                        minPosition: null,
                        referenceBuffer: null,
                        scaleFactor: null,
                        startIndex: null,
                        type: 'BAM'
                    };
                    for (let i = 0; i < values.length; i++) {
                        const localResult = values[i];
                        // merge info
                        if (!result.id) {
                            result.id = localResult.id;
                        }
                        if (!result.scaleFactor) {
                            result.scaleFactor = localResult.scaleFactor;
                        }
                        if (!result.chromosome) {
                            result.chromosome = localResult.chromosome;
                        }
                        if (!result.startIndex || result.startIndex < localResult.startIndex) {
                            result.startIndex = localResult.startIndex;
                        }
                        if (!result.endIndex || result.endIndex > localResult.endIndex) {
                            result.endIndex = localResult.endIndex;
                        }
                        // merge baseCoverage;
                        if (localResult.baseCoverage) {
                            for (let j = 0; j < localResult.baseCoverage.length; j++) {
                                result.baseCoverage.push(localResult.baseCoverage[j]);
                            }
                        }
                        //downsample coverage
                        if (localResult.downsampleCoverage) {
                            for (let j = 0; j < localResult.downsampleCoverage.length; j++) {
                                result.downsampleCoverage.push(localResult.downsampleCoverage[j]);
                            }
                        }
                        // merge reference buffer
                        if (localResult.referenceBuffer) {
                            if (!result.referenceBuffer) {
                                result.referenceBuffer = localResult.referenceBuffer;
                                result.minPosition = localResult.minPosition;
                            } else if (result.minPosition > localResult.minPosition) {
                                let newBuffer = localResult.referenceBuffer;
                                const delta = localResult.minPosition + newBuffer.length - result.minPosition;
                                if (delta > 0) {
                                    newBuffer = newBuffer.slice(0, delta);
                                } else {
                                    for (let b = 0; b < Math.abs(delta); b++) {
                                        newBuffer += ' ';
                                    }
                                }
                                result.referenceBuffer = newBuffer + result.referenceBuffer;
                                result.minPosition = localResult.minPosition;
                            } else {
                                let newBuffer = result.referenceBuffer;
                                const delta = result.minPosition + newBuffer.length - localResult.minPosition;
                                if (delta > 0) {
                                    newBuffer = newBuffer.slice(0, delta);
                                } else {
                                    for (let b = 0; b < Math.abs(delta); b++) {
                                        newBuffer += ' ';
                                    }
                                }
                                result.referenceBuffer = newBuffer + localResult.referenceBuffer;
                            }
                        }

                        // merge reads
                        if (localResult.blocks) {
                            for (let j = 0; j < localResult.blocks.length; j++) {
                                result.blocks.push(localResult.blocks[j]);
                            }
                        }
                    }
                    resolve(result);
                    result = null;
                });
            });
        } else {
            return getReadsFn(parameters);
        }
    }