export function catalogController()

in ui-modules/catalog/app/views/catalog/catalog.state.js [52:186]
84 lines of code
14 McCabe index (conditional complexity)

export function catalogController($scope, $rootScope, catalogApi, brUtilsGeneral) {
    const orderBysBundles = [{
        id: 'name',
        label: 'Name'
    }, {
        id: '-version',
        label: 'Version'
    }, {
        id: '-types',
        label: 'Most types'
    }, {
        id: 'types',
        label: 'Least types'
    }];
    const orderBysTypes = [{
        id: 'displayName',
        label: 'Display name'
    }, {
        id: 'id',
        label: 'Type name'
    }, {
        id: '-version',
        label: 'Version'
    }, {
        id: 'supertypes',
        label: 'Supertype'
    }, {
        id: 'containingBundle',
        label: 'Bundle'
    }];

    const savedOrderByKey = 'catalog-order-by';

    const savedOrderBy = localStorage && localStorage.getItem(savedOrderByKey) !== null ?
        JSON.parse(localStorage.getItem(savedOrderByKey))
        : {
            orderBy: 'bundles',
            sortBy: 0
        }

    $scope.pagination = {
        page: 1, // not used
        itemsPerPage: 20  // used as an absolute limit
    };
    $scope.config = {
        orderBy: savedOrderBy.orderBy === 'bundles' ? orderBysBundles : orderBysTypes
    };
    $scope.state = {
        view: savedOrderBy.orderBy,
        versions: [],
        orderBy: $scope.config.orderBy.length > savedOrderBy.sortBy ? $scope.config.orderBy[savedOrderBy.sortBy] : 0,
        search: {}
    };

    $scope.$watch('state.view', (newView, oldView) => {
        if (newView && oldView && !angular.equals(newView, oldView)) {
            $scope.config.orderBy = newView === 'types' ? orderBysTypes : orderBysBundles;
            $scope.state.orderBy = $scope.config.orderBy[0]
            savedOrderBy.orderBy = newView;
            savedOrderBy.sortBy = 0;
            if (localStorage) {
                localStorage.setItem(savedOrderByKey, JSON.stringify(savedOrderBy));
            }
        }
    });

    $scope.$watch('state.orderBy', (newOrderBy, oldOrderBy) => {
        if(newOrderBy && oldOrderBy && !angular.equals(newOrderBy, oldOrderBy)) {
            savedOrderBy.sortBy = $scope.config.orderBy.indexOf(newOrderBy);
            if (localStorage) {
                localStorage.setItem(savedOrderByKey, JSON.stringify(savedOrderBy));
            }
        }
    });

    $scope.clearSearchFilters = () => {
        $scope.state.search = {};
        $scope.state.orderBy = orderBysBundles[0];
    };

    $scope.isNonEmpty = (o) => {
        return brUtilsGeneral.isNonEmpty(o);
    };

    $scope.launchCatalogUploader = ()=> {
        $rootScope.$broadcast('open-catalog-uploader');
    };

    function getBundles(initialLoad) {
        catalogApi.getBundles({params: {detail: true}}).then(data => {
            if (initialLoad) $scope.$emit(HIDE_INTERSTITIAL_SPINNER_EVENT);
            processBundles(data);
        });
    }
    getBundles(true);
    $scope.$on(CATALOG_UPLOAD_COMPLETED, ()=>{
        getBundles(false);
    });

    function processBundles(bundles) {
        $scope.bundles = bundles;

        $scope.versions = bundles.reduce((versions, bundle) => {
            if (!versions.hasOwnProperty(bundle.symbolicName)) {
                versions[bundle.symbolicName] = [];
            }
            versions[bundle.symbolicName].push(bundle.version);
            return versions;
        }, {});
        $scope.config.versions = Array.from(Object.values($scope.versions).reduce((set, versions) => {
            versions.forEach(version => set.add(version));
            return set;
        }, new Set()));

        $scope.types = bundles.reduce((types, bundle) => {
            let typesInBundle = angular.copy(bundle.types).map(t => {
                // record the bundle
                t.bundle = {
                    symbolicName: bundle.symbolicName,
                    version: bundle.version,
                };
                
                // tidy up display so that things labelled [DEPRECATED] don't have that ugly name
                // (since we highlight deprecated things, and particularly bad since [ appears first alphabetically!)
                // [as in bundle.state.js]
                if (t.deprecated && t.displayName.match(/^[^\w]*deprecated[^\w]*/i)) {
                    t.displayName = t.displayName.replace(/^[^\w]*deprecated[^\w]*/i, '');
                }
                
                return t;
            });
            return types.concat(typesInBundle);
        }, []);
    }
}