Skip to content
Snippets Groups Projects
Select Git revision
  • d536c58fdbd69c9a853993c7e1b5ca83547ba22f
  • main default protected
  • step-3263
  • feature/plugins-cli
  • feature/vite
  • step-2484-peerreview
  • biest/issue-5051
  • tests/simplify-jsonapi-tests
  • fix/typo-in-1a70031
  • feature/broadcasting
  • database-seeders-and-factories
  • feature/peer-review-2
  • feature-feedback-jsonapi
  • feature/peerreview
  • feature/balloon-plus
  • feature/stock-images-unsplash
  • tic-2588
  • 5.0
  • 5.2
  • biest/unlock-blocks
  • biest-1514
21 results

CourseNavigation.php

Blame
  • Forked from Stud.IP / Stud.IP
    Source project has a limited visibility.
    Code owners
    Assign users and groups as approvers for specific file changes. Learn more.
    script.js 6.23 KiB
    (function ($, STUDIP) {
        'use strict';
    
        var searchTimeout = null;
        var lastRequestController = null;
    
        $(document).ready(function () {
            if (document.getElementById('trac-migrate') !== null) {
                let source = null;
                STUDIP.loadChunk('vue').then(function ({createApp}) {
                    createApp({
                        data: function () {
                            return {
                                needle: '',
                                results: false,
                                selectedTicket: false,
                            };
                        },
                        mounted () {
                            source = this.$el.dataset.source;
                        },
                        methods: {
                            searchTickets (event) {
                                const needle = this.needle.trim();
                                if (needle.trim().length < 3) {
                                    return;
                                }
    
                                if (lastRequestController) {
                                    lastRequestController.abort();
                                }
    
                                lastRequestController = new AbortController();
                                const { signal } = lastRequestController;
    
                                clearTimeout(searchTimeout);
                                searchTimeout = setTimeout(function () {
                                    const url = STUDIP.URLHelper.getURL(source, {term: needle});
                                    fetch(url, { signal }).then(response => this.results = response.json());
                                }.bind(this), 300);
                            }
                        },
                        computed: {
                            orderedResults () {
                                const needle = this.needle.trim();
                                return Object.values(this.results).sort(function (a, b) {
                                    if (a[0] === needle) {
                                        return 1;
                                    }
                                    if (b[0] === needle) {
                                        return -1;
                                    }
                                    return b[0] - a[0];
                                });
                            }
                        }
                    }).$mount('#trac-migrate');
                });
            } else if (document.getElementById('dashboard') !== null) {
                const dashboard = document.getElementById('dashboard');
                const issues = JSON.parse(dashboard.dataset.issues);
                const qmLabels = JSON.parse(dashboard.dataset.qmLabels);
                const filters = JSON.parse(dashboard.dataset.filters) || {};
                const filterStoreUrl = dashboard.dataset.filterStoreUrl;
    
                Object.values(qmLabels).forEach(abbr => {
                    if (filters[abbr] === undefined) {
                        filters[abbr] = null;
                    }
                });
    
                STUDIP.loadChunk('vue').then(({createApp}) => {
                    createApp({
                        data () {
                            return {
                                needle: '',
                                issues,
                                qmLabels,
                                filters
                            };
                        },
                        methods: {
                            getStateForIssueAndQmLabel(issue, qm) {
                                return issue.qm_states[qm];
                            },
                            valueMatchesNeedle(what) {
                                if (this.needle.length === 0) {
                                    return false;
                                }
    
                                return what.toLowerCase().includes(this.needle.toLowerCase());
                            }
                        },
                        computed: {
                            colspan() {
                                return 8 + Object.values(qmLabels).length;
                            },
                            filteredIssues() {
                                let filtered = this.issues.filter(issue => {
                                    for (const [key, value] of Object.entries(this.filters)) {
                                        if (value === null) {
                                            continue;
                                        }
                                        if (issue.qm_states[key] !== value) {
                                            return false;
                                        }
                                    }
                                    return true;
                                });
    
                                if (this.needle.length > 0) {
                                    filtered = filtered.filter(issue => {
                                        const ciNeedle = this.needle.toLowerCase();
                                        return issue.iid.toString().includes(this.needle)
                                            || issue.title.toLowerCase().includes(ciNeedle)
                                            || (issue.assignee ?? '').toLowerCase().includes(ciNeedle)
                                            || (issue.author ?? '').toLowerCase().includes(ciNeedle)
                                            || issue.reviewers.some(reviewer => reviewer.toLowerCase().includes(ciNeedle));
                                    });
                                }
    
                                return filtered;
                            }
                        },
                        watch: {
                            filters: {
                                handler(current) {
                                    const data = new URLSearchParams();
    
                                    for (const [label, value] of Object.entries(current)) {
                                        if (value !== null) {
                                            data.append(`filters[${label}]`, value);
                                        }
                                    }
    
                                    fetch(filterStoreUrl, {
                                        method: 'POST',
                                        body: data
                                    });
                                },
                                deep: true
                            }
                        }
                    }).$mount('#dashboard');
                });
            }
        });
    }(jQuery, STUDIP));