326 lines
9.9 KiB
TypeScript
326 lines
9.9 KiB
TypeScript
import DeleteIcon from '@mui/icons-material/Delete';
|
|
import FilterListIcon from '@mui/icons-material/FilterList';
|
|
import Box from '@mui/material/Box';
|
|
import Checkbox from '@mui/material/Checkbox';
|
|
import FormControlLabel from '@mui/material/FormControlLabel';
|
|
import IconButton from '@mui/material/IconButton';
|
|
import Paper from '@mui/material/Paper';
|
|
import { alpha } from '@mui/material/styles';
|
|
import Switch from '@mui/material/Switch';
|
|
import Table from '@mui/material/Table';
|
|
import TableBody from '@mui/material/TableBody';
|
|
import TableCell from '@mui/material/TableCell';
|
|
import TableContainer from '@mui/material/TableContainer';
|
|
import TableHead from '@mui/material/TableHead';
|
|
import TablePagination from '@mui/material/TablePagination';
|
|
import TableRow from '@mui/material/TableRow';
|
|
import TableSortLabel from '@mui/material/TableSortLabel';
|
|
import Toolbar from '@mui/material/Toolbar';
|
|
import Tooltip from '@mui/material/Tooltip';
|
|
import Typography from '@mui/material/Typography';
|
|
import { visuallyHidden } from '@mui/utils';
|
|
import React, { useState } from 'react';
|
|
|
|
import { ClientTableView, StyledStatus } from './ClientsTableView';
|
|
|
|
interface Data {
|
|
clientCode: number,
|
|
name: string,
|
|
unity: string,
|
|
status: string,
|
|
}
|
|
|
|
function createData(
|
|
clientCode: number,
|
|
name: string,
|
|
unity: string,
|
|
status: string,
|
|
): Data {
|
|
return {
|
|
clientCode,
|
|
name,
|
|
unity,
|
|
status,
|
|
};
|
|
}
|
|
|
|
const rows = [
|
|
createData(9500130, 'Copel', 'clique para ver unidades', 'ativo'),
|
|
createData(9500131, 'Copel', 'clique para ver unidades', 'ativo'),
|
|
createData(9500132, 'Copel', 'clique para ver unidades', 'ativo'),
|
|
createData(9500689, 'Copel', 'clique para ver unidades', 'pendente'),
|
|
createData(9500690, 'Copel', 'clique para ver unidades', 'inativo'),
|
|
createData(9500691, 'Copel', 'clique para ver unidades', 'inativo'),
|
|
];
|
|
|
|
function descendingComparator<T>(a: T, b: T, orderBy: keyof T) {
|
|
if (b[orderBy] < a[orderBy]) {
|
|
return -1;
|
|
}
|
|
if (b[orderBy] > a[orderBy]) {
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
type Order = 'asc' | 'desc';
|
|
|
|
function getComparator<Key extends keyof any>(
|
|
order: Order,
|
|
orderBy: any,
|
|
): (
|
|
a: { [key in Key]: number | string },
|
|
b: { [key in Key]: number | string },
|
|
) => number {
|
|
return order === 'desc'
|
|
? (a, b) => descendingComparator(a, b, orderBy)
|
|
: (a, b) => -descendingComparator(a, b, orderBy);
|
|
}
|
|
|
|
function stableSort<T>(array: readonly T[], comparator: (a: T, b: T) => number) {
|
|
const stabilizedThis = array.map((el, index) => [el, index] as [T, number]);
|
|
stabilizedThis.sort((a, b) => {
|
|
const order = comparator(a[0], b[0]);
|
|
if (order !== 0) {
|
|
return order;
|
|
}
|
|
return a[1] - b[1];
|
|
});
|
|
return stabilizedThis.map((el) => el[0]);
|
|
}
|
|
|
|
interface HeadCell {
|
|
disablePadding: boolean;
|
|
id: keyof Data | string;
|
|
label: string;
|
|
numeric: boolean;
|
|
}
|
|
|
|
const headCells: readonly HeadCell[] = [
|
|
{
|
|
id: 'clientCode',
|
|
numeric: false,
|
|
disablePadding: true,
|
|
label: 'código do cliente',
|
|
},
|
|
{
|
|
id: 'name',
|
|
numeric: true,
|
|
disablePadding: false,
|
|
label: 'name',
|
|
},
|
|
{
|
|
id: 'unity',
|
|
numeric: true,
|
|
disablePadding: false,
|
|
label: 'unity',
|
|
},
|
|
{
|
|
id: 'status',
|
|
numeric: true,
|
|
disablePadding: false,
|
|
label: 'status',
|
|
},
|
|
];
|
|
|
|
interface EnhancedTableProps {
|
|
numSelected: number;
|
|
onRequestSort: (event: React.MouseEvent<unknown>, property: keyof Data) => void;
|
|
onSelectAllClick: (event: React.ChangeEvent<HTMLInputElement>) => void;
|
|
order: Order;
|
|
orderBy: string;
|
|
rowCount: number;
|
|
}
|
|
|
|
function EnhancedTableHead(props: EnhancedTableProps) {
|
|
const { onSelectAllClick, order, orderBy, numSelected, rowCount, onRequestSort } =
|
|
props;
|
|
const createSortHandler =
|
|
(property: any) => (event: React.MouseEvent<unknown>) => {
|
|
onRequestSort(event, property);
|
|
};
|
|
|
|
return (
|
|
<TableHead>
|
|
<TableRow>
|
|
<TableCell padding="checkbox">
|
|
<Checkbox
|
|
color="primary"
|
|
indeterminate={numSelected > 0 && numSelected < rowCount}
|
|
checked={rowCount > 0 && numSelected === rowCount}
|
|
onChange={onSelectAllClick}
|
|
inputProps={{
|
|
'aria-label': 'select all desserts',
|
|
}}
|
|
/>
|
|
</TableCell>
|
|
{headCells.map((headCell) => (
|
|
<TableCell
|
|
key={headCell.id}
|
|
align='left'
|
|
padding={headCell.disablePadding ? 'none' : 'normal'}
|
|
sortDirection={orderBy === headCell.id ? order : false}
|
|
>
|
|
<TableSortLabel
|
|
active={orderBy === headCell.id}
|
|
direction={orderBy === headCell.id ? order : 'asc'}
|
|
onClick={createSortHandler(headCell.id)}
|
|
>
|
|
{headCell.label}
|
|
{orderBy === headCell.id ? (
|
|
<Box component="span" sx={visuallyHidden}>
|
|
{order === 'desc' ? 'sorted descending' : 'sorted ascending'}
|
|
</Box>
|
|
) : null}
|
|
</TableSortLabel>
|
|
</TableCell>
|
|
))}
|
|
</TableRow>
|
|
</TableHead>
|
|
);
|
|
}
|
|
|
|
export default function ClientTable() {
|
|
const [order, setOrder] = useState<Order>('asc');
|
|
const [orderBy, setOrderBy] = useState<keyof Data | string>('status');
|
|
const [selected, setSelected] = useState<readonly string[]>([]);
|
|
const [page, setPage] = useState<number>(0);
|
|
const [dense, setDense] = useState<boolean>(false);
|
|
const [rowsPerPage, setRowsPerPage] = useState<number>(5);
|
|
|
|
const handleRequestSort = (
|
|
event: React.MouseEvent<unknown>,
|
|
property: keyof Data,
|
|
) => {
|
|
const isAsc = orderBy === property && order === 'asc';
|
|
setOrder(isAsc ? 'desc' : 'asc');
|
|
setOrderBy(property);
|
|
};
|
|
|
|
const handleSelectAllClick = (event: React.ChangeEvent<HTMLInputElement>) => {
|
|
if (event.target.checked) {
|
|
const newSelecteds = rows.map((n) => n.name);
|
|
setSelected(newSelecteds);
|
|
return;
|
|
}
|
|
setSelected([]);
|
|
};
|
|
|
|
const handleClick = (event: React.MouseEvent<unknown>, code: string) => {
|
|
const selectedIndex = selected.indexOf(code);
|
|
let newSelected: readonly string[] = [];
|
|
|
|
if (selectedIndex === -1) {
|
|
newSelected = newSelected.concat(selected, code);
|
|
} else if (selectedIndex === 0) {
|
|
newSelected = newSelected.concat(selected.slice(1));
|
|
} else if (selectedIndex === selected.length - 1) {
|
|
newSelected = newSelected.concat(selected.slice(0, -1));
|
|
} else if (selectedIndex > 0) {
|
|
newSelected = newSelected.concat(
|
|
selected.slice(0, selectedIndex),
|
|
selected.slice(selectedIndex + 1),
|
|
);
|
|
}
|
|
|
|
setSelected(newSelected);
|
|
};
|
|
|
|
const handleChangePage = (event: unknown, newPage: number) => {
|
|
setPage(newPage);
|
|
};
|
|
|
|
const handleChangeRowsPerPage = (event: React.ChangeEvent<HTMLInputElement>) => {
|
|
setRowsPerPage(parseInt(event.target.value, 10));
|
|
setPage(0);
|
|
};
|
|
|
|
const isSelected = (code: any) => selected.indexOf(code.toString()) !== -1;
|
|
|
|
// Avoid a layout jump when reaching the last page with empty rows.
|
|
const emptyRows =
|
|
page > 0 ? Math.max(0, (1 + page) * rowsPerPage - rows.length) : 0;
|
|
|
|
return (
|
|
<ClientTableView>
|
|
<Paper sx={{ width: '100%', mb: 2 }}>
|
|
<TableContainer>
|
|
<Table
|
|
sx={{ minWidth: 750 }}
|
|
aria-labelledby="tableTitle"
|
|
size={dense ? 'small' : 'medium'}
|
|
>
|
|
<EnhancedTableHead
|
|
numSelected={selected.length}
|
|
order={order}
|
|
orderBy={orderBy}
|
|
onSelectAllClick={handleSelectAllClick}
|
|
onRequestSort={handleRequestSort}
|
|
rowCount={rows.length}
|
|
/>
|
|
<TableBody>
|
|
{stableSort(rows, getComparator(order, orderBy))
|
|
.slice(page * rowsPerPage, page * rowsPerPage + rowsPerPage)
|
|
.map((row, index) => {
|
|
const isItemSelected = isSelected(row.clientCode);
|
|
const labelId = `enhanced-table-checkbox-${index}`;
|
|
|
|
return (
|
|
<TableRow
|
|
hover
|
|
onClick={(event) => handleClick(event, row.clientCode.toString())}
|
|
role="checkbox"
|
|
aria-checked={isItemSelected}
|
|
tabIndex={-1}
|
|
key={row.clientCode}
|
|
selected={isItemSelected}
|
|
>
|
|
<TableCell padding="checkbox">
|
|
<Checkbox
|
|
color="primary"
|
|
checked={isItemSelected}
|
|
inputProps={{
|
|
'aria-labelledby': labelId,
|
|
}}
|
|
/>
|
|
</TableCell>
|
|
<TableCell
|
|
component="th"
|
|
id={labelId}
|
|
scope="row"
|
|
padding="none"
|
|
>
|
|
Unidade - {row.clientCode}
|
|
</TableCell>
|
|
<TableCell align="left">{row.name}</TableCell>
|
|
<TableCell align="left">{row.unity}</TableCell>
|
|
<TableCell align="left"><StyledStatus status={row.status}>{row.status}</StyledStatus></TableCell>
|
|
</TableRow>
|
|
);
|
|
})}
|
|
{emptyRows > 0 && (
|
|
<TableRow
|
|
style={{
|
|
height: (dense ? 33 : 53) * emptyRows,
|
|
}}
|
|
>
|
|
<TableCell colSpan={6} />
|
|
</TableRow>
|
|
)}
|
|
</TableBody>
|
|
</Table>
|
|
</TableContainer>
|
|
<TablePagination
|
|
rowsPerPageOptions={[5, 10, 25]}
|
|
component="div"
|
|
count={rows.length}
|
|
rowsPerPage={rowsPerPage}
|
|
page={page}
|
|
onPageChange={handleChangePage}
|
|
onRowsPerPageChange={handleChangeRowsPerPage}
|
|
/>
|
|
</Paper>
|
|
</ClientTableView>
|
|
);
|
|
}
|