710 lines
27 KiB
TypeScript
710 lines
27 KiB
TypeScript
import { useEffect, useState } from 'react';
|
||
import {
|
||
ApiError,
|
||
objectId,
|
||
page,
|
||
pretty,
|
||
record,
|
||
request,
|
||
session,
|
||
tenantPath,
|
||
type RecordValue,
|
||
type Session,
|
||
type Tenant
|
||
} from './api';
|
||
import { AdminControl } from './management';
|
||
import { allowed } from './safety';
|
||
import { CatalogCheckNotice } from './catalog-check';
|
||
import { devicePlatform } from './script-catalog';
|
||
import { DeviceInventoryPanels, systemDetails } from './device-inventory';
|
||
import { DeviceCustomerTransfer } from './device-customer-transfer';
|
||
import { HypervisorAssignment, HypervisorLabel } from './device-hypervisor';
|
||
import { ErrorBox, errorText, useResource } from './resource';
|
||
import { NavIcon, orderDetailRoute } from './navigation';
|
||
import { orderTitle, Status } from './order-presentation';
|
||
import { RecoveryReview, recoveryAsset, recoveryTenant } from './recovery-review';
|
||
import { EchoProbeReview } from './echo-probe-review';
|
||
import { EchoCompletionReview } from './echo-completion-review';
|
||
import { SyncAlignmentReview } from './sync-alignment-review';
|
||
import { SystemNonstartReview } from './system-nonstart-review';
|
||
|
||
const unknown = 'Nicht gemeldet';
|
||
const number = new Intl.NumberFormat('de-DE', { maximumFractionDigits: 1 });
|
||
const date = new Intl.DateTimeFormat('de-DE', { dateStyle: 'medium', timeStyle: 'short' });
|
||
function label(value: unknown) {
|
||
return typeof value === 'string' && value.trim() ? value : unknown;
|
||
}
|
||
function time(value: unknown) {
|
||
const t = typeof value === 'string' ? Date.parse(value) : NaN;
|
||
return Number.isFinite(t) ? date.format(t) : unknown;
|
||
}
|
||
function gib(v: unknown) {
|
||
return typeof v === 'number' && Number.isFinite(v) && v >= 0 ? number.format(v / 2 ** 30) : null;
|
||
}
|
||
function capacity(free: unknown, total: unknown) {
|
||
const f = gib(free),
|
||
t = gib(total);
|
||
return f === null && t === null ? unknown : `${f ?? '–'} / ${t ?? '–'} GiB`;
|
||
}
|
||
function cpuUsage(value: unknown) {
|
||
return typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 100
|
||
? `${number.format(value)} %`
|
||
: unknown;
|
||
}
|
||
function measuredAt(value: unknown) {
|
||
const observed = time(value);
|
||
return observed === unknown ? undefined : `Gemessen am ${observed}`;
|
||
}
|
||
function cpu(d: RecordValue) {
|
||
const model = label(d.cpu_model),
|
||
count = d.cpu_logical_count;
|
||
const threads =
|
||
typeof count === 'number' && count > 0 ? `${count} log. CPU${count === 1 ? '' : 's'}` : '';
|
||
return {
|
||
primary: model === unknown ? threads || unknown : model,
|
||
secondary: model === unknown ? '' : threads
|
||
};
|
||
}
|
||
const states: Record<string, string> = {
|
||
online: 'Online',
|
||
offline: 'Offline',
|
||
never_seen: 'Ohne Erstkontakt',
|
||
revoked: 'Widerrufen',
|
||
archived: 'Archiviert',
|
||
replaced: 'Ersetzt',
|
||
unverified: 'Identität unbestätigt'
|
||
};
|
||
function Presence({ d }: { d: RecordValue }) {
|
||
const state =
|
||
typeof d.lifecycle === 'string' && d.lifecycle !== 'current' ? d.lifecycle : String(d.status);
|
||
return (
|
||
<span
|
||
className={
|
||
'presence ' + (state === 'online' ? 'online' : state === 'offline' ? 'offline' : 'historic')
|
||
}
|
||
>
|
||
<i />
|
||
{states[state] ?? 'Unbekannt'}
|
||
</span>
|
||
);
|
||
}
|
||
function Capacity({ free, total }: { free: unknown; total: unknown }) {
|
||
return (
|
||
<>
|
||
<span>{capacity(free, total)}</span>
|
||
{typeof free === 'number' &&
|
||
typeof total === 'number' &&
|
||
Number.isFinite(total) &&
|
||
free >= 0 &&
|
||
free <= total &&
|
||
total > 0 && (
|
||
<span
|
||
className="capacity-track"
|
||
title={`${number.format((100 * free) / total)} % frei`}
|
||
aria-hidden="true"
|
||
>
|
||
<i style={{ width: `${(100 * (total - free)) / total}%` }} />
|
||
</span>
|
||
)}
|
||
</>
|
||
);
|
||
}
|
||
|
||
type Target = { customer: string; ids: string[] };
|
||
type Props = {
|
||
detailPath: string;
|
||
auth: Session;
|
||
customers: Tenant[];
|
||
filter: string;
|
||
onFilter: (id: string) => void;
|
||
selection: Target;
|
||
onSelection: (s: Target) => void;
|
||
onCreateOrder: () => void;
|
||
onEnroll: () => void;
|
||
onOperation: (customer: string, id: string, jobId: string) => void;
|
||
};
|
||
function devicePath(customer: string, asset: string) {
|
||
return tenantPath(customer, '/devices/' + encodeURIComponent(asset));
|
||
}
|
||
|
||
function reportedScriptProfiles(device: RecordValue) {
|
||
const os = devicePlatform(device);
|
||
if (!os || !Array.isArray(device.capabilities)) return 'Nicht gemeldet';
|
||
const caps = new Set(device.capabilities);
|
||
if (!caps.has('run_script')) return 'Nicht gemeldet';
|
||
const windows = os === 'windows';
|
||
const identity = windows ? 'system' : 'root';
|
||
const service = windows ? 'PowerShell als Dienstkonto' : 'Shell als Dienstkonto';
|
||
if (!caps.has(os + '.base/1') || caps.has(windows ? 'linux.base/1' : 'windows.base/1')) return 'Nicht gemeldet';
|
||
if (windows && !['rmm.sync.v1', 'script.powershell/1', 'script.powershell.process_remote_signed/1'].every(cap => caps.has(cap)))
|
||
return 'Nicht gemeldet';
|
||
const admin = ['rmm.sync.v1', 'script.full_maintenance/1', 'helper.' + identity + '.v1', identity + ':run_script']
|
||
.every(capability => caps.has(capability));
|
||
return admin ? service + ' und als Administrator (' + (windows ? 'SYSTEM' : 'root') + ')' : service;
|
||
}
|
||
|
||
function DeviceDetail({
|
||
customer,
|
||
asset,
|
||
agent,
|
||
auth,
|
||
customers,
|
||
back,
|
||
openOperation,
|
||
changed
|
||
}: {
|
||
customer: string;
|
||
asset: string;
|
||
agent: string;
|
||
auth: Session;
|
||
customers: Tenant[];
|
||
back: () => void;
|
||
openOperation: (id: string, jobId: string) => void;
|
||
changed: (notice?: string) => void;
|
||
}) {
|
||
const path = devicePath(customer, asset);
|
||
const detail = useResource(
|
||
async (signal) => record(await request(path + '?agent_id=' + encodeURIComponent(agent), { signal })),
|
||
[customer, asset, agent],
|
||
true
|
||
);
|
||
const membership = useResource(
|
||
async (signal) => session(await request('/auth/session', { signal, tenantId: customer })),
|
||
[customer, auth.principal.id]
|
||
);
|
||
const [busy, setBusy] = useState(false),
|
||
[error, setError] = useState<string | null>(null);
|
||
const [confirmDelete, setConfirmDelete] = useState(false);
|
||
const [managing, setManaging] = useState(false);
|
||
const d = detail.data;
|
||
const scoped = membership.data;
|
||
const volumes = Array.isArray(d?.volumes) ? d.volumes.map((v) => record(v)) : [];
|
||
const jobs = Array.isArray(d?.recent_jobs) ? d.recent_jobs.map((v) => record(v)) : null;
|
||
const facts = d && [
|
||
['Kunde', label(d.customer_name)],
|
||
['Type', label(d.device_type)],
|
||
['Betriebssystem', label(d.os)],
|
||
...systemDetails(d, time),
|
||
['RAM frei / gesamt', capacity(d.ram_available_bytes, d.ram_total_bytes)],
|
||
['CPU', [cpu(d).primary, cpu(d).secondary].filter(Boolean).join(' · ')],
|
||
['CPU-Auslastung', [cpuUsage(d.cpu_usage_percent), measuredAt(d.cpu_usage_observed_at)].filter(Boolean).join(' · ')],
|
||
['Speicher frei / gesamt', capacity(d.disk_free_bytes, d.disk_total_bytes)],
|
||
['Letzter Kontakt', time(d.last_contact_at)],
|
||
['Inventar erhoben', time(d.observed_at)],
|
||
['Agentversion', label(d.agent_version)],
|
||
['Vom Agenten gemeldete Skriptausführung', reportedScriptProfiles(d)]
|
||
];
|
||
return (
|
||
<div className="device-detail">
|
||
<button className="quiet" onClick={back}>
|
||
<NavIcon name="zurueck" /> Zur Geräteliste
|
||
</button>
|
||
<ErrorBox error={detail.error ?? membership.error} />
|
||
{!d && !detail.error && <p>Inventar wird geladen …</p>}
|
||
{d && (
|
||
<>
|
||
<div className="page-title">
|
||
<div>
|
||
<h1>{label(d.hostname)}</h1>
|
||
<Presence d={d} />
|
||
<HypervisorLabel device={d} />
|
||
</div>
|
||
</div>
|
||
<section>
|
||
<h2>Geräteinformationen</h2>
|
||
<dl className="facts">
|
||
{facts?.map(([k, v]) => (
|
||
<div key={k}>
|
||
<dt>{k}</dt>
|
||
<dd>{v}</dd>
|
||
</div>
|
||
))}
|
||
</dl>
|
||
</section>
|
||
<DeviceInventoryPanels device={d} />
|
||
{volumes.length > 0 && (
|
||
<section>
|
||
<h2>Laufwerke</h2>
|
||
<div className="table">
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
<th>Laufwerk</th>
|
||
<th>Speicher frei / gesamt</th>
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
{volumes.map((v, i) => (
|
||
<tr key={i}>
|
||
<td>{label(v.name)}</td>
|
||
<td>{capacity(v.free_bytes, v.total_bytes)}</td>
|
||
</tr>
|
||
))}
|
||
</tbody>
|
||
</table>
|
||
</div>
|
||
</section>
|
||
)}
|
||
{jobs && (
|
||
<section>
|
||
<h2>Letzte Aufträge</h2>
|
||
{jobs.length === 0 ? (
|
||
<p className="muted">Keine Aufträge für dieses Gerät.</p>
|
||
) : (
|
||
<ul className="job-list">
|
||
{jobs.map((job) => {
|
||
const id = objectId(job, 'operation'), jobId = objectId(job, 'job');
|
||
const title = orderTitle(job);
|
||
return <li className="job-row" key={jobId}>
|
||
<div className="device-job-name"><strong>{title}</strong><small>{time(job.created_at)}</small></div>
|
||
<Status value={job.state}/>
|
||
<a className="quiet" href={'#auftraege/' + orderDetailRoute(customer, id, jobId)}
|
||
aria-label={'Ergebnis öffnen · ' + title + ' · ' + time(job.created_at)}
|
||
onClick={event => {
|
||
if (event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return;
|
||
event.preventDefault();
|
||
openOperation(id, jobId);
|
||
}}>Ergebnis öffnen</a>
|
||
</li>;
|
||
})}
|
||
</ul>
|
||
)}
|
||
</section>
|
||
)}
|
||
<section>
|
||
<details>
|
||
<summary>Technische Daten</summary>
|
||
<CatalogCheckNotice device={d} />
|
||
<pre aria-label="Vollständiges Geräteinventar">{pretty(d)}</pre>
|
||
</details>
|
||
{scoped && allowed(scoped, 'devices:revoke') &&
|
||
d.tenant_id === customer && d.asset_id === asset && d.agent_id === agent && (
|
||
<details open={managing} onToggle={e => setManaging(e.currentTarget.open)}>
|
||
<summary>Gerät verwalten</summary>
|
||
<ErrorBox error={error} />
|
||
{d.device_type === 'virtual' && d.lifecycle === 'current' &&
|
||
<HypervisorAssignment device={d} customer={customer} asset={asset} agent={agent} auth={scoped} />}
|
||
<DeviceCustomerTransfer auth={scoped} customer={customer} asset={asset} agent={agent}
|
||
customers={customers} active={d.lifecycle === 'current'}
|
||
supported={Array.isArray(d.capabilities) && d.capabilities.includes('device.customer_transfer/1')} />
|
||
{['archived', 'current'].includes(String(d.lifecycle)) && (
|
||
<button
|
||
disabled={busy}
|
||
onClick={async () => {
|
||
setBusy(true);
|
||
setError(null);
|
||
try {
|
||
await request(path + '/archive', {
|
||
csrf: scoped.csrf_token,
|
||
body: { archived: d.lifecycle !== 'archived' }
|
||
});
|
||
changed();
|
||
} catch (e) {
|
||
setError(errorText(e));
|
||
} finally {
|
||
setBusy(false);
|
||
}
|
||
}}
|
||
>
|
||
{d.lifecycle === 'archived'
|
||
? 'Zurück in den Bestand'
|
||
: 'In die Historie verschieben'}
|
||
</button>
|
||
)}
|
||
{d.lifecycle !== 'revoked' && (
|
||
<AdminControl
|
||
auth={scoped}
|
||
path={path + '/revocation?agent_id=' + encodeURIComponent(agent)}
|
||
permission="devices:revoke"
|
||
title="Geräteidentität widerrufen"
|
||
warning="Der Widerruf unterbricht die Geräteverwaltung und sperrt neue Starts. Danach können Sie diese Kopplung endgültig löschen. Eine Wiederaufnahme erfordert eine neue Registrierung."
|
||
done={detail.reload}
|
||
/>
|
||
)}
|
||
{d.lifecycle === 'revoked' && (confirmDelete ? (
|
||
<div>
|
||
<p className="warning">
|
||
Die Kopplung von <strong>{label(d.hostname)}</strong> bei <strong>{label(d.customer_name)}</strong>
|
||
{' '}wird mit ihrem Inventar und ihren Geräteergebnissen dauerhaft gelöscht.
|
||
Andere Installationen bleiben erhalten.
|
||
</p>
|
||
<p>Kopplungs-ID <code>{agent}</code></p>
|
||
<button className="danger" disabled={busy} onClick={async () => {
|
||
setBusy(true);
|
||
setError(null);
|
||
try {
|
||
await request(path + '?agent_id=' + encodeURIComponent(agent), {
|
||
method: 'DELETE', csrf: scoped.csrf_token, tenantId: customer
|
||
});
|
||
changed(`Kopplung von „${label(d.hostname)}“ bei „${label(d.customer_name)}“ gelöscht.`);
|
||
} catch (e) {
|
||
if (e instanceof ApiError && e.code === 'DEVICE_HAS_OPEN_WORK') {
|
||
setError('Für diese Kopplung gibt es offene Aufträge oder Genehmigungen. Prüfen Sie diese vor dem Löschen.');
|
||
} else if (e instanceof ApiError && e.code === 'DEVICE_REVOCATION_REQUIRED') {
|
||
setError('Widerrufen Sie diese Geräteidentität vor dem Löschen.');
|
||
} else {
|
||
setError(errorText(e));
|
||
}
|
||
} finally {
|
||
setBusy(false);
|
||
}
|
||
}}>Endgültig löschen</button>
|
||
<button className="quiet" disabled={busy} onClick={() => {
|
||
setConfirmDelete(false);
|
||
setError(null);
|
||
}}>Abbrechen</button>
|
||
</div>
|
||
) : (
|
||
<button className="danger" onClick={() => setConfirmDelete(true)}>Kopplung löschen</button>
|
||
))}
|
||
</details>
|
||
)}
|
||
</section>
|
||
{scoped?.principal.simulated &&
|
||
customer === recoveryTenant &&
|
||
asset === recoveryAsset &&
|
||
allowed(scoped, 'inventory:read') && (
|
||
<details>
|
||
<summary>Entwicklungsabnahmen</summary>
|
||
<SystemNonstartReview auth={scoped} />
|
||
<SyncAlignmentReview auth={scoped} />
|
||
<EchoProbeReview auth={scoped} />
|
||
<EchoCompletionReview auth={scoped} />
|
||
<RecoveryReview auth={scoped} />
|
||
</details>
|
||
)}
|
||
</>
|
||
)}
|
||
</div>
|
||
);
|
||
}
|
||
|
||
export function Devices({
|
||
detailPath,
|
||
auth,
|
||
customers,
|
||
filter,
|
||
onFilter,
|
||
selection,
|
||
onSelection,
|
||
onEnroll,
|
||
onCreateOrder,
|
||
onOperation
|
||
}: Props) {
|
||
const [search, setSearch] = useState(''),
|
||
[query, setQuery] = useState(''),
|
||
[status, setStatus] = useState(''),
|
||
[history, setHistory] = useState(false);
|
||
const [deletionNotice, setDeletionNotice] = useState('');
|
||
const [trail, setTrail] = useState<{ filter: string; routes: string[] }>({ filter, routes: [] });
|
||
const routes = trail.filter === filter ? trail.routes : [];
|
||
function setRoutes(next: string[] | ((old: string[]) => string[])) {
|
||
setTrail(old => ({ filter, routes: typeof next === 'function' ? next(old.filter === filter ? old.routes : []) : next }));
|
||
}
|
||
const [customerId, assetId, agentId] = detailPath.split('/');
|
||
const target =
|
||
customerId && assetId && agentId ? { customer: customerId, asset: assetId, agent: agentId } : null;
|
||
const back = () => {
|
||
window.location.hash = 'geraete';
|
||
};
|
||
const cursor = routes[routes.length - 1];
|
||
useEffect(() => {
|
||
const timer = setTimeout(() => {
|
||
setQuery(search.trim());
|
||
setRoutes([]);
|
||
}, 200);
|
||
return () => clearTimeout(timer);
|
||
}, [search]);
|
||
useEffect(() => setTrail({ filter, routes: [] }), [filter]);
|
||
const list = useResource(
|
||
async (signal) => {
|
||
if (target) return null;
|
||
const params = new URLSearchParams({ view: history ? 'history' : 'current', limit: '40' });
|
||
if (query) params.set('q', query);
|
||
if (status && !history) params.set('status', status);
|
||
if (cursor) params.set('cursor', cursor);
|
||
const path = filter ? tenantPath(filter, '/devices') : '/api/v1/devices';
|
||
return page(await request(path + '?' + params, { signal }));
|
||
},
|
||
[filter, query, history, status, cursor, detailPath],
|
||
true
|
||
);
|
||
function setView(historic: boolean) {
|
||
setRoutes([]);
|
||
setHistory(historic);
|
||
onSelection({ customer: '', ids: [] });
|
||
}
|
||
function select(d: RecordValue, checked: boolean) {
|
||
const asset = objectId(d, 'asset'),
|
||
customer = objectId(d, 'tenant');
|
||
if (checked && selection.ids.length && customer !== selection.customer) return;
|
||
const ids = checked ? [...selection.ids, asset] : selection.ids.filter((id) => id !== asset);
|
||
onSelection({ customer: ids.length ? customer : '', ids });
|
||
}
|
||
if (target)
|
||
return (
|
||
<DeviceDetail
|
||
key={detailPath}
|
||
{...target}
|
||
auth={auth}
|
||
customers={customers}
|
||
back={back}
|
||
openOperation={(id, jobId) => onOperation(target.customer, id, jobId)}
|
||
changed={(notice) => {
|
||
setDeletionNotice(notice ?? '');
|
||
back();
|
||
setRoutes([]);
|
||
onSelection({ customer: '', ids: [] });
|
||
list.reload();
|
||
}}
|
||
/>
|
||
);
|
||
return (
|
||
<>
|
||
<div className="page-title">
|
||
<div>
|
||
<h1>Geräte</h1>
|
||
</div>
|
||
{allowed(auth, 'devices:enroll') && (
|
||
<button className="primary" onClick={onEnroll}>
|
||
<NavIcon name="plus" /> Gerät aufnehmen
|
||
</button>
|
||
)}
|
||
</div>
|
||
{deletionNotice && <p role="status">{deletionNotice}</p>}
|
||
<section className="fleet" aria-label="Gerätebestand">
|
||
<div className="fleet-tabs">
|
||
<button
|
||
aria-pressed={!history}
|
||
onClick={() => {
|
||
if (history) setView(false);
|
||
}}
|
||
>
|
||
Bestand
|
||
</button>
|
||
<button
|
||
aria-pressed={history}
|
||
onClick={() => {
|
||
if (!history) setView(true);
|
||
}}
|
||
>
|
||
Historie
|
||
</button>
|
||
</div>
|
||
<div className="filters">
|
||
<label className="search-box">
|
||
<span className="sr-only">Hostname suchen</span>
|
||
<NavIcon name="suchen" />
|
||
<input
|
||
type="search"
|
||
placeholder="Hostname suchen …"
|
||
maxLength={120}
|
||
value={search}
|
||
onChange={(e) => setSearch(e.target.value)}
|
||
/>
|
||
</label>
|
||
<label>
|
||
<span>Kunde im Gerätebestand</span>
|
||
<select
|
||
aria-label="Kunde im Gerätebestand"
|
||
value={filter}
|
||
onChange={(e) => {
|
||
setRoutes([]);
|
||
onFilter(e.target.value);
|
||
}}
|
||
>
|
||
<option value="">Alle Kunden</option>
|
||
{customers.map((c) => (
|
||
<option value={c.tenant_id} key={c.tenant_id}>
|
||
{c.name}
|
||
</option>
|
||
))}
|
||
</select>
|
||
</label>
|
||
{!history && (
|
||
<label>
|
||
<span>Status</span>
|
||
<select
|
||
aria-label="Status"
|
||
value={status}
|
||
onChange={(e) => {
|
||
setRoutes([]);
|
||
setStatus(e.target.value);
|
||
}}
|
||
>
|
||
<option value="">Jeder Status</option>
|
||
<option value="online">Online</option>
|
||
<option value="offline">Offline</option>
|
||
</select>
|
||
</label>
|
||
)}
|
||
</div>
|
||
<ErrorBox error={list.error} />
|
||
{history && (
|
||
<p className="history-hint">
|
||
Ausgemusterte Geräte und Registrierungen ohne bestätigte Identität.
|
||
</p>
|
||
)}
|
||
{!list.data && !list.error && <p className="list-message">Geräte werden geladen …</p>}
|
||
{list.data && (
|
||
<>
|
||
<div className="table fleet-table">
|
||
<table>
|
||
<thead>
|
||
<tr>
|
||
{!history && (
|
||
<th className="target-col">
|
||
<span className="sr-only">Ziel auswählen</span>
|
||
</th>
|
||
)}
|
||
{['Hostname', 'Type', 'OS', 'Status', 'Speicher frei / gesamt', 'RAM frei / gesamt', 'CPU', 'Kunde'].map(
|
||
(h) => (
|
||
<th scope="col" key={h}>
|
||
{h}
|
||
</th>
|
||
)
|
||
)}
|
||
</tr>
|
||
</thead>
|
||
<tbody>
|
||
{list.data.items.map((d) => {
|
||
const asset = objectId(d, 'asset'),
|
||
agent = objectId(d, 'agent'),
|
||
customer = objectId(d, 'tenant'),
|
||
model = cpu(d);
|
||
const show = () => {
|
||
setDeletionNotice('');
|
||
window.location.hash = ['geraete', customer, asset, agent]
|
||
.map(encodeURIComponent)
|
||
.join('/');
|
||
};
|
||
const another = selection.ids.length > 0 && selection.customer !== customer;
|
||
return (
|
||
<tr key={agent} onClick={show}>
|
||
{!history && (
|
||
<td className="target-col" onClick={(e) => e.stopPropagation()}>
|
||
<input
|
||
type="checkbox"
|
||
aria-label={'Ziel ' + asset}
|
||
title={
|
||
another ? 'Aufträge werden je Kunde geplant' : 'Für Auftrag auswählen'
|
||
}
|
||
disabled={another}
|
||
checked={selection.customer === customer && selection.ids.includes(asset)}
|
||
onChange={(e) => select(d, e.target.checked)}
|
||
/>
|
||
</td>
|
||
)}
|
||
<td className="hostname">
|
||
<button
|
||
className="host-link"
|
||
onClick={(e) => {
|
||
e.stopPropagation();
|
||
show();
|
||
}}
|
||
>
|
||
{label(d.hostname)}
|
||
</button>
|
||
<HypervisorLabel device={d} />
|
||
</td>
|
||
<td data-label="Type">{label(d.device_type)}</td>
|
||
<td data-label="OS">{label(d.os)}</td>
|
||
<td data-label="Status" className="device-presence">
|
||
<Presence d={d} />
|
||
{d.status === 'offline' && d.lifecycle === 'current' && (
|
||
<small>Zuletzt {time(d.last_contact_at)}</small>
|
||
)}
|
||
</td>
|
||
<td data-label="Speicher frei / gesamt" className="capacity-cell">
|
||
<Capacity free={d.disk_free_bytes} total={d.disk_total_bytes} />
|
||
</td>
|
||
<td data-label="RAM frei / gesamt" className="capacity-cell" title={measuredAt(d.ram_observed_at)}>
|
||
<Capacity free={d.ram_available_bytes} total={d.ram_total_bytes} />
|
||
</td>
|
||
<td data-label="CPU">
|
||
{model.primary}
|
||
{model.secondary && <small>{model.secondary}</small>}
|
||
<small title={measuredAt(d.cpu_usage_observed_at)}>
|
||
Auslastung {cpuUsage(d.cpu_usage_percent)}
|
||
</small>
|
||
</td>
|
||
<td data-label="Kunde">{label(d.customer_name)}</td>
|
||
</tr>
|
||
);
|
||
})}
|
||
</tbody>
|
||
</table>
|
||
</div>
|
||
{!list.data.items.length && (
|
||
<div className="empty-list">
|
||
<NavIcon name="geraete" />
|
||
<h3>
|
||
{query || filter || status
|
||
? 'Keine passenden Geräte'
|
||
: 'Keine Geräte in dieser Ansicht'}
|
||
</h3>
|
||
{(query || filter || status) && (
|
||
<button
|
||
className="quiet"
|
||
onClick={() => {
|
||
setSearch('');
|
||
setQuery('');
|
||
setRoutes([]);
|
||
setStatus('');
|
||
onFilter('');
|
||
}}
|
||
>
|
||
Filter zurücksetzen
|
||
</button>
|
||
)}
|
||
</div>
|
||
)}
|
||
<div className="list-footer">
|
||
<span>
|
||
{list.data.items.length} {list.data.items.length === 1 ? 'Gerät' : 'Geräte'}
|
||
{cursor || list.data.next_cursor ? ' auf dieser Seite' : ''} · Stand{' '}
|
||
{time(list.data.as_of)}
|
||
</span>
|
||
{(cursor || list.data.next_cursor) && (
|
||
<div>
|
||
<button
|
||
className="quiet"
|
||
disabled={!cursor}
|
||
onClick={() => setRoutes((old) => old.slice(0, -1))}
|
||
>
|
||
Zurück
|
||
</button>
|
||
<button
|
||
className="quiet"
|
||
disabled={!list.data.next_cursor}
|
||
onClick={() => {
|
||
const next = list.data?.next_cursor;
|
||
if (next) setRoutes((old) => [...old, next]);
|
||
}}
|
||
>
|
||
Weiter
|
||
</button>
|
||
</div>
|
||
)}
|
||
</div>
|
||
</>
|
||
)}
|
||
</section>
|
||
{!!selection.ids.length && (
|
||
<div className="selection">
|
||
<div>
|
||
<strong>
|
||
{selection.ids.length} {selection.ids.length === 1 ? 'Gerät' : 'Geräte'} ausgewählt
|
||
</strong>
|
||
<small>{customers.find((c) => c.tenant_id === selection.customer)?.name}</small>
|
||
</div>
|
||
<button className="quiet" onClick={() => onSelection({ customer: '', ids: [] })}>
|
||
Auswahl aufheben
|
||
</button>
|
||
<button disabled={!allowed(auth, 'operations:plan') || !allowed(auth, 'scripts:execute')} onClick={onCreateOrder}>Auftrag erstellen</button>
|
||
</div>
|
||
)}
|
||
</>
|
||
);
|
||
}
|