File Manager

X7ROOT File Manager

Current Path: /home/cbholdings/pasukulu/lib/amd/src

home / cbholdings / pasukulu / lib / amd / src /

📁 ..
📄 adapter.js(123.08 KB)
📄 addblockmodal.js(4.4 KB)
📄 ajax.js(11.97 KB)
📄 aria.js(1011 B)
📄 auto_rows.js(3.46 KB)
📄 autoscroll.js(6.49 KB)
📄 backoff_timer.js(4.98 KB)
📄 chart_axis.js(7.39 KB)
📄 chart_bar.js(3.08 KB)
📄 chart_base.js(11.36 KB)
📄 chart_builder.js(1.65 KB)
📄 chart_line.js(2.08 KB)
📄 chart_output.js(1.08 KB)
📄 chart_output_base.js(2.03 KB)
📄 chart_output_chartjs.js(10.86 KB)
📄 chart_output_htmltable.js(3.3 KB)
📄 chart_pie.js(3.03 KB)
📄 chart_series.js(8.35 KB)
📄 chartjs-lazy.js(488.32 KB)
📄 chartjs.js(913 B)
📄 checkbox-toggleall.js(12.78 KB)
📄 config.js(1002 B)
📄 copy_to_clipboard.js(7.39 KB)
📄 custom_interaction_events.js(22.18 KB)
📁 datafilter
📄 datafilter.js(15.28 KB)
📄 dragdrop.js(12.92 KB)
📄 drawer.js(3.49 KB)
📄 drawer_events.js(967 B)
📄 dynamic_tabs.js(6.68 KB)
📄 edit_switch.js(3.45 KB)
📁 emoji
📄 event.js(3.11 KB)
📄 event_dispatcher.js(2.79 KB)
📄 first.js(1.36 KB)
📄 form-autocomplete.js(51.21 KB)
📄 form-cohort-selector.js(2.46 KB)
📄 form-course-selector.js(3.77 KB)
📄 fragment.js(5.03 KB)
📄 fullscreen.js(1.62 KB)
📄 icon_system.js(2.56 KB)
📄 icon_system_fontawesome.js(4.01 KB)
📄 icon_system_standard.js(2.3 KB)
📄 inplace_editable.js(17.25 KB)
📄 key_codes.js(1.34 KB)
📄 loadingicon.js(3.88 KB)
📁 local
📄 localstorage.js(2.08 KB)
📄 log.js(1.74 KB)
📄 loglevel.js(10.63 KB)
📄 menu_navigation.js(9.2 KB)
📄 modal.js(31.18 KB)
📄 modal_backdrop.js(4.46 KB)
📄 modal_cancel.js(1.49 KB)
📄 modal_copy_to_clipboard.js(3.82 KB)
📄 modal_delete_cancel.js(2.22 KB)
📄 modal_events.js(1.35 KB)
📄 modal_factory.js(8.97 KB)
📄 modal_registry.js(2.38 KB)
📄 modal_save_cancel.js(2.21 KB)
📁 moodlenet
📄 moremenu.js(10.3 KB)
📄 mustache.js(28.75 KB)
📄 network.js(9.66 KB)
📄 normalise.js(1.9 KB)
📄 notification.js(11.8 KB)
📄 page_global.js(5.38 KB)
📄 paged_content.js(2.87 KB)
📄 paged_content_events.js(1.17 KB)
📄 paged_content_factory.js(20.93 KB)
📄 paged_content_pages.js(11.75 KB)
📄 paged_content_paging_bar.js(20.36 KB)
📄 paged_content_paging_bar_limit_selector.js(2.36 KB)
📄 paged_content_paging_dropdown.js(7.36 KB)
📄 pending.js(4.48 KB)
📄 permissionmanager.js(9.77 KB)
📄 popover_region_controller.js(13.04 KB)
📄 popper.js(79.2 KB)
📄 prefetch.js(5.85 KB)
📄 process_monitor.js(3.55 KB)
📄 pubsub.js(2.17 KB)
📄 reactive.js(1.38 KB)
📄 scroll_manager.js(5.5 KB)
📄 sessionstorage.js(2.22 KB)
📄 showhidesettings.js(11.82 KB)
📄 sortable_list.js(29.51 KB)
📄 sticky-footer.js(2.58 KB)
📄 storagewrapper.js(5.21 KB)
📄 str.js(7.84 KB)
📄 tag.js(19.84 KB)
📄 templates.js(51.36 KB)
📄 toast.js(3.32 KB)
📄 tooltip.js(4.09 KB)
📄 tree.js(18.39 KB)
📄 truncate.js(6.56 KB)
📄 url.js(3.65 KB)
📄 user_date.js(9.32 KB)
📄 userfeedback.js(2.91 KB)
📄 usermenu.js(5.13 KB)
📄 utility.js(6.15 KB)
📄 utils.js(2.73 KB)
📄 yui.js(1.13 KB)

Editing: datafilter.js

// This file is part of Moodle - http://moodle.org/
//
// Moodle is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// Moodle is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**
 * Data filter management.
 *
 * @module     core/datafilter
 * @copyright  2020 Andrew Nicols <andrew@nicols.co.uk>
 * @license    http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later
 */

import CourseFilter from 'core/datafilter/filtertypes/courseid';
import GenericFilter from 'core/datafilter/filtertype';
import {get_strings as getStrings} from 'core/str';
import Notification from 'core/notification';
import Pending from 'core/pending';
import Selectors from 'core/datafilter/selectors';
import Templates from 'core/templates';
import CustomEvents from 'core/custom_interaction_events';
import jQuery from 'jquery';

export default class {

/**
     * Initialise the filter on the element with the given filterSet and callback.
     *
     * @param {HTMLElement} filterSet The filter element.
     * @param {Function} applyCallback Callback function when updateTableFromFilter
     */
    constructor(filterSet, applyCallback) {

this.filterSet = filterSet;
        this.applyCallback = applyCallback;
        // Keep a reference to all of the active filters.
        this.activeFilters = {
            courseid: new CourseFilter('courseid', filterSet),
        };
    }

/**
     * Initialise event listeners to the filter.
     */
    init() {
        // Add listeners for the main actions.
        this.filterSet.querySelector(Selectors.filterset.region).addEventListener('click', e => {
            if (e.target.closest(Selectors.filterset.actions.addRow)) {
                e.preventDefault();

this.addFilterRow();
            }

if (e.target.closest(Selectors.filterset.actions.applyFilters)) {
                e.preventDefault();

this.updateTableFromFilter();
            }

if (e.target.closest(Selectors.filterset.actions.resetFilters)) {
                e.preventDefault();

this.removeAllFilters();
            }
        });

// Add the listener to remove a single filter.
        this.filterSet.querySelector(Selectors.filterset.regions.filterlist).addEventListener('click', e => {
            if (e.target.closest(Selectors.filter.actions.remove)) {
                e.preventDefault();

this.removeOrReplaceFilterRow(e.target.closest(Selectors.filter.region), true);
            }
        });

// Add listeners for the filter type selection.
        let filterRegion = jQuery(this.getFilterRegion());
        CustomEvents.define(filterRegion, [CustomEvents.events.accessibleChange]);
        filterRegion.on(CustomEvents.events.accessibleChange, e => {
            const typeField = e.target.closest(Selectors.filter.fields.type);
            if (typeField && typeField.value) {
                const filter = e.target.closest(Selectors.filter.region);

this.addFilter(filter, typeField.value);
            }
        });

this.filterSet.querySelector(Selectors.filterset.fields.join).addEventListener('change', e => {
            this.filterSet.dataset.filterverb = e.target.value;
        });
    }

/**
     * Get the filter list region.
     *
     * @return {HTMLElement}
     */
    getFilterRegion() {
        return this.filterSet.querySelector(Selectors.filterset.regions.filterlist);
    }

/**
     * Add an unselected filter row.
     *
     * @return {Promise}
     */
    addFilterRow() {
        const pendingPromise = new Pending('core/datafilter:addFilterRow');
        const rownum = 1 + this.getFilterRegion().querySelectorAll(Selectors.filter.region).length;
        return Templates.renderForPromise('core/datafilter/filter_row', {"rownumber": rownum})
            .then(({html, js}) => {
                const newContentNodes = Templates.appendNodeContents(this.getFilterRegion(), html, js);

return newContentNodes;
            })
            .then(filterRow => {
                // Note: This is a nasty hack.
                // We should try to find a better way of doing this.
                // We do not have the list of types in a readily consumable format, so we take the pre-rendered one and copy
                // it in place.
                const typeList = this.filterSet.querySelector(Selectors.data.typeList);

filterRow.forEach(contentNode => {
                    const contentTypeList = contentNode.querySelector(Selectors.filter.fields.type);

if (contentTypeList) {
                        contentTypeList.innerHTML = typeList.innerHTML;
                    }
                });

return filterRow;
            })
            .then(filterRow => {
                this.updateFiltersOptions();

return filterRow;
            })
            .then(result => {
                pendingPromise.resolve();

return result;
            })
            .catch(Notification.exception);
    }

/**
     * Get the filter data source node fro the specified filter type.
     *
     * @param {String} filterType
     * @return {HTMLElement}
     */
    getFilterDataSource(filterType) {
        const filterDataNode = this.filterSet.querySelector(Selectors.filterset.regions.datasource);

return filterDataNode.querySelector(Selectors.data.fields.byName(filterType));
    }

/**
     * Add a filter to the list of active filters, performing any necessary setup.
     *
     * @param {HTMLElement} filterRow
     * @param {String} filterType
     * @param {Array} initialFilterValues The initially selected values for the filter
     * @returns {Filter}
     */
    async addFilter(filterRow, filterType, initialFilterValues) {
        // Name the filter on the filter row.
        filterRow.dataset.filterType = filterType;

const filterDataNode = this.getFilterDataSource(filterType);

// Instantiate the Filter class.
        let Filter = GenericFilter;
        if (filterDataNode.dataset.filterTypeClass) {
            Filter = await import(filterDataNode.dataset.filterTypeClass);
        }
        this.activeFilters[filterType] = new Filter(filterType, this.filterSet, initialFilterValues);

// Disable the select.
        const typeField = filterRow.querySelector(Selectors.filter.fields.type);
        typeField.value = filterType;
        typeField.disabled = 'disabled';

// Update the list of available filter types.
        this.updateFiltersOptions();

return this.activeFilters[filterType];
    }

/**
     * Get the registered filter class for the named filter.
     *
     * @param {String} name
     * @return {Object} See the Filter class.
     */
    getFilterObject(name) {
        return this.activeFilters[name];
    }

/**
     * Remove or replace the specified filter row and associated class, ensuring that if there is only one filter row,
     * that it is replaced instead of being removed.
     *
     * @param {HTMLElement} filterRow
     * @param {Bool} refreshContent Whether to refresh the table content when removing
     */
    removeOrReplaceFilterRow(filterRow, refreshContent) {
        const filterCount = this.getFilterRegion().querySelectorAll(Selectors.filter.region).length;
        if (filterCount === 1) {
            this.replaceFilterRow(filterRow, refreshContent);
        } else {
            this.removeFilterRow(filterRow, refreshContent);
        }
    }

/**
     * Remove the specified filter row and associated class.
     *
     * @param {HTMLElement} filterRow
     * @param {Bool} refreshContent Whether to refresh the table content when removing
     */
    async removeFilterRow(filterRow, refreshContent = true) {
        const filterType = filterRow.querySelector(Selectors.filter.fields.type);
        const hasFilterValue = !!filterType.value;

// Remove the filter object.
        this.removeFilterObject(filterRow.dataset.filterType);

// Remove the actual filter HTML.
        filterRow.remove();

// Update the list of available filter types.
        this.updateFiltersOptions();

if (hasFilterValue && refreshContent) {
            // Refresh the table if there was any content in this row.
            this.updateTableFromFilter();
        }

// Update filter fieldset legends.
        const filterLegends = await this.getAvailableFilterLegends();

this.getFilterRegion().querySelectorAll(Selectors.filter.region).forEach((filterRow, index) => {
            filterRow.querySelector('legend').innerText = filterLegends[index];
        });

}

/**
     * Replace the specified filter row with a new one.
     *
     * @param {HTMLElement} filterRow
     * @param {Bool} refreshContent Whether to refresh the table content when removing
     * @param {Number} rowNum The number used to label the filter fieldset legend (eg Row 1). Defaults to 1 (the first filter).
     * @return {Promise}
     */
    replaceFilterRow(filterRow, refreshContent = true, rowNum = 1) {
        // Remove the filter object.
        this.removeFilterObject(filterRow.dataset.filterType);

return Templates.renderForPromise('core/datafilter/filter_row', {"rownumber": rowNum})
            .then(({html, js}) => {
                const newContentNodes = Templates.replaceNode(filterRow, html, js);

filterRow.forEach(contentNode => {
                    const contentTypeList = contentNode.querySelector(Selectors.filter.fields.type);

if (contentTypeList) {
                        contentTypeList.innerHTML = typeList.innerHTML;
                    }
                });

return filterRow;
            })
            .then(filterRow => {
                this.updateFiltersOptions();

return filterRow;
            })
            .then(filterRow => {
                // Refresh the table.
                if (refreshContent) {
                    return this.updateTableFromFilter();
                } else {
                    return filterRow;
                }
            })
            .catch(Notification.exception);
    }

/**
     * Remove the Filter Object from the register.
     *
     * @param {string} filterName The name of the filter to be removed
     */
    removeFilterObject(filterName) {
        if (filterName) {
            const filter = this.getFilterObject(filterName);
            if (filter) {
                filter.tearDown();

// Remove from the list of active filters.
                delete this.activeFilters[filterName];
            }
        }
    }

/**
     * Remove all filters.
     *
     * @returns {Promise}
     */
    removeAllFilters() {
        const filters = this.getFilterRegion().querySelectorAll(Selectors.filter.region);
        filters.forEach(filterRow => this.removeOrReplaceFilterRow(filterRow, false));

// Refresh the table.
        return this.updateTableFromFilter();
    }

/**
     * Remove any empty filters.
     */
    removeEmptyFilters() {
        const filters = this.getFilterRegion().querySelectorAll(Selectors.filter.region);
        filters.forEach(filterRow => {
            const filterType = filterRow.querySelector(Selectors.filter.fields.type);
            if (!filterType.value) {
                this.removeOrReplaceFilterRow(filterRow, false);
            }
        });
    }

/**
     * Update the list of filter types to filter out those already selected.
     */
    updateFiltersOptions() {
        const filters = this.getFilterRegion().querySelectorAll(Selectors.filter.region);
        filters.forEach(filterRow => {
            const options = filterRow.querySelectorAll(Selectors.filter.fields.type + ' option');
            options.forEach(option => {
                if (option.value === filterRow.dataset.filterType) {
                    option.classList.remove('hidden');
                    option.disabled = false;
                } else if (this.activeFilters[option.value]) {
                    option.classList.add('hidden');
                    option.disabled = true;
                } else {
                    option.classList.remove('hidden');
                    option.disabled = false;
                }
            });
        });

// Configure the state of the "Add row" button.
        // This button is disabled when there is a filter row available for each condition.
        const addRowButton = this.filterSet.querySelector(Selectors.filterset.actions.addRow);
        const filterDataNode = this.filterSet.querySelectorAll(Selectors.data.fields.all);
        if (filterDataNode.length <= filters.length) {
            addRowButton.setAttribute('disabled', 'disabled');
        } else {
            addRowButton.removeAttribute('disabled');
        }

if (filters.length === 1) {
            this.filterSet.querySelector(Selectors.filterset.regions.filtermatch).classList.add('hidden');
            this.filterSet.querySelector(Selectors.filterset.fields.join).value = 2;
            this.filterSet.dataset.filterverb = 2;
        } else {
            this.filterSet.querySelector(Selectors.filterset.regions.filtermatch).classList.remove('hidden');
        }
    }

/**
     * Update the Dynamic table based upon the current filter.
     */
    updateTableFromFilter() {
        const pendingPromise = new Pending('core/datafilter:updateTableFromFilter');

const filters = {};
        Object.values(this.activeFilters).forEach(filter => {
            filters[filter.filterValue.name] = filter.filterValue;
        });

if (this.applyCallback) {
            this.applyCallback(filters, pendingPromise);
        }
    }

/**
     * Fetch the strings used to populate the fieldset legends for the maximum number of filters possible.
     *
     * @return {array}
     */
    async getAvailableFilterLegends() {
        const maxFilters = document.querySelector(Selectors.data.typeListSelect).length - 1;
        let requests = [];

[...Array(maxFilters)].forEach((_, rowIndex) => {
            requests.push({
                "key": "filterrowlegend",
                "component": "core",
                // Add 1 since rows begin at 1 (index begins at zero).
                "param": rowIndex + 1
            });
        });

const legendStrings = await getStrings(requests)
            .then(fetchedStrings => {
                return fetchedStrings;
            })
            .catch(Notification.exception);

return legendStrings;
    }

}

X7ROOT File Manager

Editing: datafilter.js

Upload File

Create Folder