238 lines
7.7 KiB
TypeScript
238 lines
7.7 KiB
TypeScript
import { Button, ButtonGroup, Code, HTMLTable, Intent, NonIdealState, Spinner } from "@blueprintjs/core";
|
|
import { IconNames } from "@blueprintjs/icons";
|
|
import { push } from "connected-react-router";
|
|
import { range, sortBy, sortedUniq, zip } from "lodash";
|
|
import * as numeral from "numeral";
|
|
import React from "react";
|
|
import { connect } from "react-redux";
|
|
import { Dispatch } from "redux";
|
|
import styled from "styled-components";
|
|
import { loadInstanceList } from "../../redux/actions";
|
|
import { IAppState, IInstanceListResponse, IInstanceSort, SortField } from "../../redux/types";
|
|
import { InstanceType } from "../atoms";
|
|
import { ErrorState } from "../molecules";
|
|
|
|
const StyledTable = styled(HTMLTable)`
|
|
width: 100%;
|
|
`;
|
|
const PaginationContainer = styled.div`
|
|
margin-top: 20px;
|
|
display: flex;
|
|
flex-direction: column;
|
|
flex: 1;
|
|
align-items: center;
|
|
`;
|
|
const InstanceColumn = styled.th`
|
|
width: 15%;
|
|
`;
|
|
const ServerColumn = styled.th`
|
|
width: 20%;
|
|
`;
|
|
const VersionColumn = styled.th`
|
|
width: 20%;
|
|
`;
|
|
const UserCountColumn = styled.th`
|
|
width: 15%;
|
|
`;
|
|
const StatusCountColumn = styled.th`
|
|
width: 15%;
|
|
`;
|
|
const InsularityColumn = styled.th`
|
|
width: 15%;
|
|
`;
|
|
|
|
interface IInstanceTableProps {
|
|
loadError: boolean;
|
|
instancesResponse?: IInstanceListResponse;
|
|
instanceListSort: IInstanceSort;
|
|
isLoading: boolean;
|
|
loadInstanceList: (page?: number, sort?: IInstanceSort) => void;
|
|
navigate: (path: string) => void;
|
|
}
|
|
class InstanceTable extends React.PureComponent<IInstanceTableProps> {
|
|
public componentDidMount() {
|
|
const { isLoading, instancesResponse, loadError } = this.props;
|
|
if (!isLoading && !instancesResponse && !loadError) {
|
|
this.props.loadInstanceList();
|
|
}
|
|
}
|
|
|
|
public render() {
|
|
const { isLoading, instancesResponse, loadError } = this.props;
|
|
if (loadError) {
|
|
return <ErrorState />;
|
|
} else if (isLoading || !instancesResponse) {
|
|
return <NonIdealState icon={<Spinner />} />;
|
|
}
|
|
|
|
const { instances, pageNumber: currentPage, totalPages, totalEntries, pageSize } = instancesResponse!;
|
|
const pagesToDisplay = this.getPagesToDisplay(totalPages, currentPage);
|
|
|
|
return (
|
|
<>
|
|
<StyledTable striped={true} bordered={true} interactive={true}>
|
|
<thead>
|
|
<tr>
|
|
<InstanceColumn>
|
|
Instance
|
|
<Button
|
|
minimal={true}
|
|
icon={this.getSortIcon("domain")}
|
|
onClick={this.sortByFactory("domain")}
|
|
intent={this.getSortIntent("domain")}
|
|
/>
|
|
</InstanceColumn>
|
|
<ServerColumn>Server type</ServerColumn>
|
|
<VersionColumn>Version</VersionColumn>
|
|
<UserCountColumn>
|
|
Users
|
|
<Button
|
|
minimal={true}
|
|
icon={this.getSortIcon("userCount")}
|
|
onClick={this.sortByFactory("userCount")}
|
|
intent={this.getSortIntent("userCount")}
|
|
/>
|
|
</UserCountColumn>
|
|
<StatusCountColumn>
|
|
Statuses
|
|
<Button
|
|
minimal={true}
|
|
icon={this.getSortIcon("statusCount")}
|
|
onClick={this.sortByFactory("statusCount")}
|
|
intent={this.getSortIntent("statusCount")}
|
|
/>
|
|
</StatusCountColumn>
|
|
<InsularityColumn>
|
|
Insularity
|
|
<Button
|
|
minimal={true}
|
|
icon={this.getSortIcon("insularity")}
|
|
onClick={this.sortByFactory("insularity")}
|
|
intent={this.getSortIntent("insularity")}
|
|
/>
|
|
</InsularityColumn>
|
|
</tr>
|
|
</thead>
|
|
<tbody>
|
|
{instances.map(i => (
|
|
<tr key={i.name} onClick={this.goToInstanceFactory(i.name)}>
|
|
<td>{i.name}</td>
|
|
<td>{i.type && <InstanceType type={i.type} />}</td>
|
|
<td>{i.version && <Code>{i.version}</Code>}</td>
|
|
<td>{i.userCount && numeral.default(i.userCount).format("0,0")}</td>
|
|
<td>{i.statusCount && numeral.default(i.statusCount).format("0,0")}</td>
|
|
<td>{i.insularity && numeral.default(i.insularity).format("0.0%")}</td>
|
|
</tr>
|
|
))}
|
|
</tbody>
|
|
</StyledTable>
|
|
|
|
<PaginationContainer>
|
|
<p>
|
|
Showing {(currentPage - 1) * pageSize + 1}-{Math.min(currentPage * pageSize, totalEntries)} of{" "}
|
|
{totalEntries} known active instances
|
|
</p>
|
|
|
|
<ButtonGroup>
|
|
{zip(pagesToDisplay, pagesToDisplay.slice(1)).map(([page, nextPage], idx) => {
|
|
if (page === undefined) {
|
|
return null;
|
|
}
|
|
const isCurrentPage = currentPage === page;
|
|
const isEndOfSection = nextPage !== undefined && page + 1 !== nextPage && page !== totalPages;
|
|
|
|
return (
|
|
<>
|
|
<Button
|
|
key={page}
|
|
onClick={this.loadPageFactory(page)}
|
|
disabled={isCurrentPage}
|
|
intent={isCurrentPage ? Intent.PRIMARY : undefined}
|
|
>
|
|
{page}
|
|
</Button>
|
|
{isEndOfSection && (
|
|
<Button disabled={true} key={"..."}>
|
|
{"..."}
|
|
</Button>
|
|
)}
|
|
</>
|
|
);
|
|
})}
|
|
</ButtonGroup>
|
|
</PaginationContainer>
|
|
</>
|
|
);
|
|
}
|
|
|
|
private sortByFactory = (field: SortField) => () => {
|
|
const { instancesResponse, instanceListSort } = this.props;
|
|
|
|
const page = (instancesResponse && instancesResponse.pageNumber) || 1;
|
|
const nextSortDirection =
|
|
instanceListSort.field === field && instanceListSort.direction === "desc" ? "asc" : "desc";
|
|
|
|
this.props.loadInstanceList(page, { field, direction: nextSortDirection });
|
|
};
|
|
|
|
private loadPageFactory = (page: number) => () => {
|
|
this.props.loadInstanceList(page);
|
|
};
|
|
|
|
private goToInstanceFactory = (domain: string) => () => {
|
|
this.props.navigate(`/instance/${domain}`);
|
|
};
|
|
|
|
private getSortIcon = (field: SortField) => {
|
|
const { instanceListSort } = this.props;
|
|
if (instanceListSort.field !== field) {
|
|
return IconNames.SORT;
|
|
} else if (instanceListSort.direction === "asc") {
|
|
return IconNames.SORT_ASC;
|
|
} else {
|
|
return IconNames.SORT_DESC;
|
|
}
|
|
};
|
|
|
|
private getSortIntent = (field: SortField) => {
|
|
const { instanceListSort } = this.props;
|
|
if (instanceListSort.field === field) {
|
|
return Intent.PRIMARY;
|
|
} else {
|
|
return Intent.NONE;
|
|
}
|
|
};
|
|
|
|
private getPagesToDisplay = (totalPages: number, currentPage: number) => {
|
|
if (totalPages < 10) {
|
|
return range(1, totalPages + 1);
|
|
}
|
|
|
|
const firstPages = range(1, 3);
|
|
const surroundingPages = range(Math.max(currentPage - 1, 1), Math.min(currentPage + 2, totalPages));
|
|
const lastPages = range(totalPages - 1, totalPages + 1);
|
|
|
|
const pagesToDisplay = firstPages.concat(surroundingPages).concat(lastPages);
|
|
|
|
return sortedUniq(sortBy(pagesToDisplay, n => n));
|
|
};
|
|
}
|
|
|
|
const mapStateToProps = (state: IAppState) => {
|
|
return {
|
|
instanceListSort: state.data.instanceListSort,
|
|
instancesResponse: state.data.instancesResponse,
|
|
isLoading: state.data.isLoadingInstanceList,
|
|
loadError: state.data.instanceListLoadError
|
|
};
|
|
};
|
|
const mapDispatchToProps = (dispatch: Dispatch) => ({
|
|
loadInstanceList: (page?: number, sort?: IInstanceSort) => dispatch(loadInstanceList(page, sort) as any),
|
|
navigate: (path: string) => dispatch(push(path))
|
|
});
|
|
|
|
export default connect(
|
|
mapStateToProps,
|
|
mapDispatchToProps
|
|
)(InstanceTable);
|