aswi20220x00-gitlab/webapp/pages/documents/admin/index.tsx @ 0db53e25

import 'antd/dist/antd.css';
import React, { useContext, useEffect, useState } from 'react';

import { useUnauthRedirect } from '../../../hooks';
import { useRouter } from 'next/router';
import { Button, Input, Space, Table, Typography } from 'antd';
import { faFileLines, faUser } from '@fortawesome/free-solid-svg-icons';
import { FontAwesomeIcon } from '@fortawesome/react-fontawesome';
import { LoggedUserContext } from '../../../contexts/LoggedUserContext';
import { MainLayout } from '../../../layouts/MainLayout';
import AddDocumentModal from '../../../components/modals/AddDocumentModal';
import { DocumentListInfo, UserInfo } from '../../../api';
import { documentController, userController } from '../../../controllers';
import AssignDocumentModal from '../../../components/modals/AssignDocumentModal';
import { ShowToast } from '../../../utils/alerts';
import { TableDocInfo } from '../../../components/types/TableDocInfo';
import { SearchOutlined } from '@ant-design/icons';
import { UserFilter } from '../../../components/types/UserFilter';

function AdminDocumentPage() {
    const redirecting = useUnauthRedirect('/login');
    const { logout, role } = useContext(LoggedUserContext);
    const [visibleAdd, setVisibleAdd] = React.useState(false);
    const [visibleAssign, setVisibleAssign] = React.useState(false);
    const router = useRouter();

    const [documents, setDocuments] = useState<TableDocInfo[]>([]);
    const [userFilters, setUserFilters] = useState<UserFilter[]>([]);
    const [selectedDocs, setSelectedDocs] = useState<string[] | undefined[]>([]);

    async function fetchData() {
        const docs = (await documentController.documentsGet(0, 1000)).data.documents;
        // @ts-ignore
        const tableDocs: TableDocInfo[] = docs?.map((doc, index) => {
            return { key: index, ...doc };
        });

        const users = (await userController.usersGet()).data.users;
        // @ts-ignore
        const filters: UserFilter[] = users?.map((user) => {
            return {
                text: user.name + ' ' + user.surname,
                value: user.username,
            };
        });
        setUserFilters(filters);

        if (!docs) {
            setDocuments([]);
        } else {
            setDocuments(tableDocs);
        }
    }

    useEffect(() => {
        if (!redirecting && role === 'ADMINISTRATOR') {
            fetchData();
        }
    }, [logout, redirecting, role, router]);

    const showAssignModal = () => {
        if (selectedDocs.length == 0) {
            ShowToast('Vyberte dokument pro přiřazení', 'warning', 3000, 'top-end');
        } else {
            setVisibleAssign(true);
        }
    };

    const showAddModal = () => {
        setVisibleAdd(true);
    };

    const hideModal = () => {
        fetchData();
        setVisibleAdd(false);
        setVisibleAssign(false);
    };

    const handleSearch = (
        selectedKeys: React.SetStateAction<string>[],
        confirm: () => void
    ) => {
        confirm();
    };

    const handleReset = (clearFilters: () => void) => {
        clearFilters();
    };

    const getColumnSearchProps = (dataIndex: string, searchLabel: string) => ({
        // @ts-ignore
        filterDropdown: ({ setSelectedKeys, selectedKeys, confirm, clearFilters }) => (
            <div style={{ padding: 8 }}>
                <Input
                    placeholder={`Vyhledat ${searchLabel}`}
                    value={selectedKeys[0]}
                    onChange={(e) =>
                        setSelectedKeys(e.target.value ? [e.target.value] : [])
                    }
                    onPressEnter={() => handleSearch(selectedKeys, confirm)}
                    style={{ marginBottom: 8, display: 'block' }}
                />
                <Space>
                    <Button
                        type="primary"
                        onClick={() => handleSearch(selectedKeys, confirm)}
                        icon={<SearchOutlined />}
                        style={{ width: 90 }}
                    >
                        Hledat
                    </Button>
                    <Button
                        onClick={() => handleReset(clearFilters)}
                        style={{ width: 90 }}
                    >
                        Smazat
                    </Button>
                </Space>
            </div>
        ),
        filterIcon: (filtered: any) => (
            <SearchOutlined style={{ color: filtered ? '#1890ff' : undefined }} />
        ),
        onFilter: (value: string, record: { [x: string]: { toString: () => string } }) =>
            record[dataIndex]
                ? record[dataIndex].toString().toLowerCase().includes(value.toLowerCase())
                : '',
    });

    const columns = [
        {
            title: 'Název dokumentu',
            dataIndex: 'name',
            key: 'name',
            ...getColumnSearchProps('name', 'název'),
        },
        {
            title: 'Délka',
            dataIndex: 'length',
            key: 'length',
            sorter: {
                // @ts-ignore
                compare: (a, b) => a.length - b.length,
                multiple: 1,
            },
            sortDirections: ['descend', 'ascend'],
        },
        {
            title: 'Anotátoři',
            dataIndex: 'annotatingUsers',
            key: 'annotatingUsers',
            render: (columnData: UserInfo[], record: DocumentListInfo, index: number) => {
                return (
                    <div>
                        {columnData.map((e) => (
                            <span
                                key={e.username + '.' + record.id}
                                title={e.username ?? ''}
                            >
                                <FontAwesomeIcon
                                    icon={faUser}
                                    title={e.username ?? ''}
                                    className={'me-2'}
                                />
                            </span>
                        ))}
                    </div>
                );
            },
            filters: userFilters,
            filterSearch: true,
            // @ts-ignore
            onFilter: (value, record) =>
                // @ts-ignore
                record.annotatingUsers.find((user) => user['username'] === value),
            sorter: {
                // @ts-ignore
                compare: (a, b) => a.annotatingUsers.length - b.annotatingUsers.length,
                multiple: 1,
            },
            sortDirections: ['descend', 'ascend'],
        },
    ];

    const rowSelection = {
        onChange: (selectedRowKeys: React.Key[], selectedRows: DocumentListInfo[]) => {
            // @ts-ignore
            setSelectedDocs(selectedRows.map((row) => row.id));
        },
    };

    return redirecting || role !== 'ADMINISTRATOR' ? null : (
        <MainLayout>
            <Typography.Title level={2}>
                <FontAwesomeIcon icon={faFileLines} /> Dokumenty
            </Typography.Title>
            <Button type={'primary'} onClick={showAddModal}>
                Nahrát dokument
            </Button>
            <Button onClick={showAssignModal}>Přiřadit dokumenty</Button>
            {visibleAdd && <AddDocumentModal onCancel={hideModal} />}
            {visibleAssign && (
                <AssignDocumentModal documentsIds={selectedDocs} onCancel={hideModal} />
            )}

            <Table
                locale={{
                    filterSearchPlaceholder: 'Hledat uživatele',
                    triggerDesc: 'Seřadit sestupně',
                    triggerAsc: 'Seřadit vzestupně',
                    cancelSort: 'Vypnout řazení',
                }}
                rowSelection={{
                    type: 'checkbox',
                    ...rowSelection,
                }}
                // @ts-ignore
                columns={columns}
                dataSource={documents}
                size="middle"
                scroll={{ y: 600 }}
            />
        </MainLayout>
    );
}

export default AdminDocumentPage;