688 lines
24 KiB
TypeScript
688 lines
24 KiB
TypeScript
import { FastifyInstance } from "fastify"
|
|
import { promises as fs } from "node:fs"
|
|
import net from "node:net"
|
|
import path from "node:path"
|
|
import { and, desc, eq } from "drizzle-orm"
|
|
import { telephonyCalls, telephonyTrunks } from "../../db/schema"
|
|
|
|
const envFlag = (value: string | undefined, fallback: boolean) => {
|
|
if (value === undefined || value === "") return fallback
|
|
return ["1", "true", "yes", "on"].includes(value.toLowerCase())
|
|
}
|
|
|
|
const telephonyEnabled = () =>
|
|
envFlag(process.env.TELEPHONY_ENABLED, process.env.NODE_ENV !== "production")
|
|
|
|
const asteriskHttpStatusUrl = () =>
|
|
process.env.TELEPHONY_ASTERISK_HTTP_URL || "http://asterisk-dev:8088/ws"
|
|
|
|
const asteriskHttpStatusUrls = () => {
|
|
const configuredUrl = asteriskHttpStatusUrl()
|
|
return Array.from(new Set([
|
|
configuredUrl,
|
|
"http://asterisk-dev:8088/ws",
|
|
"http://host.docker.internal:8088/ws",
|
|
`http://127.0.0.1:${process.env.TELEPHONY_DEV_WS_PORT || "8088"}/ws`,
|
|
`http://localhost:${process.env.TELEPHONY_DEV_WS_PORT || "8088"}/ws`,
|
|
]))
|
|
}
|
|
|
|
const publicAsteriskWsUrl = () =>
|
|
process.env.TELEPHONY_ASTERISK_WS_URL || `ws://localhost:${process.env.TELEPHONY_DEV_WS_PORT || "8088"}/ws`
|
|
|
|
const defaultAsteriskGeneratedDir = () => {
|
|
const cwd = process.cwd()
|
|
return path.resolve(cwd, cwd.endsWith(`${path.sep}backend`) ? "../telephony/generated" : "telephony/generated")
|
|
}
|
|
|
|
const asteriskGeneratedDir = () =>
|
|
process.env.TELEPHONY_ASTERISK_GENERATED_DIR || defaultAsteriskGeneratedDir()
|
|
|
|
const defaultAsteriskAmiHost = () =>
|
|
process.env.NODE_ENV === "production" ? "asterisk-dev" : "127.0.0.1"
|
|
|
|
const asteriskAmiConfig = () => ({
|
|
host: process.env.TELEPHONY_ASTERISK_AMI_HOST || defaultAsteriskAmiHost(),
|
|
port: Number(process.env.TELEPHONY_ASTERISK_AMI_PORT || 5038),
|
|
username: process.env.TELEPHONY_ASTERISK_AMI_USER || "fedeo",
|
|
password: process.env.TELEPHONY_ASTERISK_AMI_PASSWORD || "fedeo-ami-dev",
|
|
})
|
|
|
|
const sipDomain = () =>
|
|
process.env.TELEPHONY_SIP_DOMAIN || "localhost"
|
|
|
|
const testAccounts = () => [
|
|
{
|
|
extension: process.env.TELEPHONY_TEST_EXTENSION || "1001",
|
|
password: process.env.TELEPHONY_TEST_PASSWORD || "fedeo-test-1001",
|
|
displayName: "FEDEO Test 1001",
|
|
},
|
|
{
|
|
extension: process.env.TELEPHONY_TEST_EXTENSION_2 || "1002",
|
|
password: process.env.TELEPHONY_TEST_PASSWORD_2 || "fedeo-test-1002",
|
|
displayName: "FEDEO Test 1002",
|
|
},
|
|
]
|
|
|
|
const sanitizeTrunk = (trunk: any) => ({
|
|
id: trunk?.id || null,
|
|
provider: trunk?.provider || "telekom",
|
|
enabled: Boolean(trunk?.enabled),
|
|
registrar: trunk?.registrar || "tel.t-online.de",
|
|
sipUser: trunk?.sipUser || "",
|
|
authUser: trunk?.authUser || "",
|
|
passwordConfigured: Boolean(trunk?.password),
|
|
callerId: trunk?.callerId || "",
|
|
inboundExtension: trunk?.inboundExtension || "1001",
|
|
outboundPrefix: trunk?.outboundPrefix || "0",
|
|
externalSignalingAddress: trunk?.externalSignalingAddress || "",
|
|
externalMediaAddress: trunk?.externalMediaAddress || "",
|
|
localNetworks: trunk?.localNetworks || "172.16.0.0/12,192.168.0.0/16,10.0.0.0/8",
|
|
})
|
|
|
|
const envExternalTelephonyConfig = () => {
|
|
const provider = process.env.TELEPHONY_EXTERNAL_PROVIDER || (
|
|
envFlag(process.env.TELEPHONY_TELEKOM_ENABLED, false) ? "telekom" : ""
|
|
)
|
|
const enabled = envFlag(
|
|
process.env.TELEPHONY_EXTERNAL_ENABLED,
|
|
envFlag(process.env.TELEPHONY_TELEKOM_ENABLED, false)
|
|
)
|
|
|
|
return {
|
|
enabled,
|
|
provider: provider || null,
|
|
inboundExtension: process.env.TELEPHONY_EXTERNAL_INBOUND_EXTENSION
|
|
|| process.env.TELEPHONY_TELEKOM_INBOUND_EXTENSION
|
|
|| "1001",
|
|
outboundPrefix: process.env.TELEPHONY_TELEKOM_OUTBOUND_PREFIX || "0",
|
|
registrar: provider === "telekom" || envFlag(process.env.TELEPHONY_TELEKOM_ENABLED, false)
|
|
? (process.env.TELEPHONY_TELEKOM_REGISTRAR || "tel.t-online.de")
|
|
: null,
|
|
sipUserConfigured: Boolean(process.env.TELEPHONY_TELEKOM_SIP_USER),
|
|
authUserConfigured: Boolean(process.env.TELEPHONY_TELEKOM_AUTH_USER),
|
|
passwordConfigured: Boolean(process.env.TELEPHONY_TELEKOM_PASSWORD),
|
|
callerIdConfigured: Boolean(process.env.TELEPHONY_TELEKOM_CALLER_ID),
|
|
}
|
|
}
|
|
|
|
const fetchWithTimeout = async (url: string, timeoutMs = 2500) => {
|
|
const controller = new AbortController()
|
|
const timeout = setTimeout(() => controller.abort(), timeoutMs)
|
|
|
|
try {
|
|
return await fetch(url, { signal: controller.signal })
|
|
} finally {
|
|
clearTimeout(timeout)
|
|
}
|
|
}
|
|
|
|
const requireTenant = (tenantId: number | null) => {
|
|
if (!tenantId) {
|
|
throw Object.assign(new Error("Kein aktiver Mandant"), { statusCode: 400 })
|
|
}
|
|
|
|
return tenantId
|
|
}
|
|
|
|
const bodyString = (body: any, key: string) => {
|
|
const value = body?.[key]
|
|
return typeof value === "string" && value.trim() ? value.trim() : null
|
|
}
|
|
|
|
const bodyDate = (body: any, key: string) => {
|
|
const value = body?.[key]
|
|
if (!value) return null
|
|
|
|
const date = new Date(value)
|
|
return Number.isNaN(date.getTime()) ? null : date
|
|
}
|
|
|
|
const durationSeconds = (startedAt?: Date | null, endedAt?: Date | null) => {
|
|
if (!startedAt || !endedAt) return null
|
|
return Math.max(0, Math.round((endedAt.getTime() - startedAt.getTime()) / 1000))
|
|
}
|
|
|
|
const asteriskValue = (value: string | null | undefined) =>
|
|
String(value || "").replace(/[\r\n]/g, "").trim()
|
|
|
|
const renderTelekomPjsipConfig = (trunk: any) => {
|
|
if (!trunk?.enabled) {
|
|
return [
|
|
"; Von FEDEO generiert.",
|
|
"; Telekom-Trunk ist deaktiviert.",
|
|
"",
|
|
].join("\n")
|
|
}
|
|
|
|
const registrar = asteriskValue(trunk.registrar) || "tel.t-online.de"
|
|
const sipUser = asteriskValue(trunk.sipUser)
|
|
const authUser = asteriskValue(trunk.authUser) || sipUser
|
|
const password = asteriskValue(trunk.password)
|
|
const callerId = asteriskValue(trunk.callerId) || sipUser
|
|
const externalMediaAddress = asteriskValue(trunk.externalMediaAddress || trunk.externalSignalingAddress)
|
|
|
|
return [
|
|
"; Von FEDEO generiert. Änderungen im Container können überschrieben werden.",
|
|
"[telekom-auth]",
|
|
"type=auth",
|
|
"auth_type=userpass",
|
|
`username=${authUser}`,
|
|
`password=${password}`,
|
|
"",
|
|
"[telekom-aor]",
|
|
"type=aor",
|
|
`contact=sip:${registrar}`,
|
|
"",
|
|
"[telekom]",
|
|
"type=endpoint",
|
|
"transport=transport-udp",
|
|
"context=from-telekom",
|
|
"disallow=all",
|
|
"allow=alaw,ulaw",
|
|
"aors=telekom-aor",
|
|
"outbound_auth=telekom-auth",
|
|
`from_user=${sipUser}`,
|
|
`from_domain=${registrar}`,
|
|
`callerid=Telekom <${callerId}>`,
|
|
...(externalMediaAddress ? [`media_address=${externalMediaAddress}`] : []),
|
|
"direct_media=no",
|
|
"force_rport=yes",
|
|
"rewrite_contact=yes",
|
|
"rtp_symmetric=yes",
|
|
"timers=no",
|
|
"",
|
|
"[telekom-identify]",
|
|
"type=identify",
|
|
"endpoint=telekom",
|
|
`match=${registrar}`,
|
|
"",
|
|
"[telekom-registration]",
|
|
"type=registration",
|
|
"transport=transport-udp",
|
|
"outbound_auth=telekom-auth",
|
|
`server_uri=sip:${registrar}`,
|
|
`client_uri=sip:${sipUser}@${registrar}`,
|
|
`contact_user=${sipUser}`,
|
|
"retry_interval=60",
|
|
"forbidden_retry_interval=300",
|
|
"expiration=480",
|
|
"line=yes",
|
|
"endpoint=telekom",
|
|
"",
|
|
].join("\n")
|
|
}
|
|
|
|
const renderTelekomExtensionsConfig = (trunk: any) => {
|
|
if (!trunk?.enabled) {
|
|
return [
|
|
"; Von FEDEO generiert.",
|
|
"; Telekom-Routing ist deaktiviert.",
|
|
"",
|
|
].join("\n")
|
|
}
|
|
|
|
const inboundExtension = asteriskValue(trunk.inboundExtension) || "1001"
|
|
const outboundPrefix = asteriskValue(trunk.outboundPrefix) || "0"
|
|
const escapedPrefix = outboundPrefix.replace(/[^0-9*#+]/g, "")
|
|
const callerId = asteriskValue(trunk.callerId) || asteriskValue(trunk.sipUser)
|
|
|
|
return [
|
|
"; Von FEDEO generiert. Änderungen im Container können überschrieben werden.",
|
|
"[fedeo-local]",
|
|
escapedPrefix
|
|
? `exten => _${escapedPrefix}X.,1,NoOp(FEDEO ausgehend über Telekom: $` + "{EXTEN})"
|
|
: "exten => _X.,1,NoOp(FEDEO ausgehend über Telekom: ${EXTEN})",
|
|
` same => n,Set(CALLERID(num)=${callerId})`,
|
|
" same => n,Dial(PJSIP/${EXTEN}@telekom,60)",
|
|
" same => n,Hangup()",
|
|
"",
|
|
"exten => _+X.,1,NoOp(FEDEO ausgehend über Telekom: ${EXTEN})",
|
|
` same => n,Set(CALLERID(num)=${callerId})`,
|
|
" same => n,Dial(PJSIP/${EXTEN}@telekom,60)",
|
|
" same => n,Hangup()",
|
|
"",
|
|
"[from-telekom]",
|
|
"exten => s,1,NoOp(FEDEO eingehend über Telekom)",
|
|
` same => n,Dial(PJSIP/${inboundExtension},30)`,
|
|
" same => n,Hangup()",
|
|
"",
|
|
"exten => _X!,1,NoOp(FEDEO eingehend über Telekom: ${EXTEN})",
|
|
` same => n,Dial(PJSIP/${inboundExtension},30)`,
|
|
" same => n,Hangup()",
|
|
"",
|
|
].join("\n")
|
|
}
|
|
|
|
const renderTelekomTransportConfig = (trunk: any) => {
|
|
const externalSignalingAddress = asteriskValue(trunk?.externalSignalingAddress)
|
|
const externalMediaAddress = asteriskValue(trunk?.externalMediaAddress || trunk?.externalSignalingAddress)
|
|
const localNetworks = asteriskValue(trunk?.localNetworks || "172.16.0.0/12,192.168.0.0/16,10.0.0.0/8")
|
|
.split(/[\s,;]+/)
|
|
.map((entry) => entry.trim())
|
|
.filter(Boolean)
|
|
|
|
if (!externalSignalingAddress && !externalMediaAddress) {
|
|
return [
|
|
"; Von FEDEO generiert.",
|
|
"; Kein externes Asterisk-NAT-Rewrite konfiguriert.",
|
|
"",
|
|
].join("\n")
|
|
}
|
|
|
|
return [
|
|
"; Von FEDEO generiert. Änderungen am Transport benötigen einen Asterisk-Neustart.",
|
|
"[transport-udp](+)",
|
|
...(externalSignalingAddress ? [
|
|
`external_signaling_address=${externalSignalingAddress}`,
|
|
"external_signaling_port=5060",
|
|
] : []),
|
|
...(externalMediaAddress ? [`external_media_address=${externalMediaAddress}`] : []),
|
|
...localNetworks.map((network) => `local_net=${network}`),
|
|
"",
|
|
].join("\n")
|
|
}
|
|
|
|
const writeAsteriskTrunkConfig = async (trunk: any) => {
|
|
const targetDir = asteriskGeneratedDir()
|
|
await fs.mkdir(targetDir, { recursive: true })
|
|
|
|
const files = [
|
|
{
|
|
name: "pjsip.telekom.conf",
|
|
content: renderTelekomPjsipConfig(trunk),
|
|
},
|
|
{
|
|
name: "extensions.telekom.conf",
|
|
content: renderTelekomExtensionsConfig(trunk),
|
|
},
|
|
{
|
|
name: "pjsip.transport.conf",
|
|
content: renderTelekomTransportConfig(trunk),
|
|
},
|
|
]
|
|
|
|
await Promise.all(files.map(async (file) => {
|
|
const target = path.join(targetDir, file.name)
|
|
await fs.writeFile(target, `${file.content}\n`, { mode: 0o644 })
|
|
await fs.chmod(target, 0o644)
|
|
}))
|
|
|
|
return files.map((file) => path.join(targetDir, file.name))
|
|
}
|
|
|
|
const runAsteriskAmiCommand = async (command: string, timeoutMs = 5000) => {
|
|
const config = asteriskAmiConfig()
|
|
|
|
return await new Promise<{ command: string, ok: boolean, raw: string }>((resolve, reject) => {
|
|
const socket = net.createConnection(config.port, config.host)
|
|
let raw = ""
|
|
let settled = false
|
|
|
|
const finish = (ok: boolean) => {
|
|
if (settled) return
|
|
settled = true
|
|
socket.destroy()
|
|
resolve({ command, ok, raw })
|
|
}
|
|
|
|
socket.setTimeout(timeoutMs)
|
|
socket.on("connect", () => {
|
|
socket.write([
|
|
"Action: Login",
|
|
`Username: ${config.username}`,
|
|
`Secret: ${config.password}`,
|
|
"Events: off",
|
|
"",
|
|
"Action: Command",
|
|
`Command: ${command}`,
|
|
"",
|
|
"Action: Logoff",
|
|
"",
|
|
].join("\r\n"))
|
|
})
|
|
socket.on("data", (chunk) => {
|
|
raw += chunk.toString("utf8")
|
|
if (raw.includes("Goodbye")) finish(!raw.includes("Authentication failed"))
|
|
})
|
|
socket.on("timeout", () => finish(raw.length > 0))
|
|
socket.on("end", () => finish(!raw.includes("Authentication failed")))
|
|
socket.on("error", reject)
|
|
})
|
|
}
|
|
|
|
const runAsteriskReload = async () => {
|
|
const commands = [
|
|
"module reload res_pjsip.so",
|
|
"dialplan reload",
|
|
"pjsip send register telekom-registration",
|
|
]
|
|
const results = []
|
|
|
|
for (const command of commands) {
|
|
results.push(await runAsteriskAmiCommand(command))
|
|
}
|
|
|
|
return {
|
|
ok: results.every((result) => result.ok),
|
|
commands: results,
|
|
}
|
|
}
|
|
|
|
const readAsteriskTrunkStatus = async () => {
|
|
const registrations = await runAsteriskAmiCommand("pjsip show registrations")
|
|
const raw = registrations.raw || ""
|
|
|
|
return {
|
|
reachable: registrations.ok,
|
|
registered: /telekom-registration[\s\S]*Registered/i.test(raw),
|
|
hasRegistration: raw.includes("telekom-registration"),
|
|
registrations: raw,
|
|
}
|
|
}
|
|
|
|
export default async function telephonyRoutes(server: FastifyInstance) {
|
|
const loadTenantTrunk = async (tenantId: number | null, provider = "telekom") => {
|
|
if (!tenantId) return null
|
|
|
|
const [trunk] = await server.db
|
|
.select()
|
|
.from(telephonyTrunks)
|
|
.where(and(
|
|
eq(telephonyTrunks.tenantId, tenantId),
|
|
eq(telephonyTrunks.provider, provider)
|
|
))
|
|
.limit(1)
|
|
|
|
return trunk || null
|
|
}
|
|
|
|
const externalTelephonyConfig = async (tenantId: number | null) => {
|
|
const trunk = await loadTenantTrunk(tenantId)
|
|
if (trunk) {
|
|
return {
|
|
enabled: trunk.enabled,
|
|
provider: trunk.provider,
|
|
inboundExtension: trunk.inboundExtension,
|
|
outboundPrefix: trunk.outboundPrefix,
|
|
registrar: trunk.registrar,
|
|
externalSignalingAddress: trunk.externalSignalingAddress,
|
|
externalMediaAddress: trunk.externalMediaAddress,
|
|
localNetworks: trunk.localNetworks,
|
|
sipUserConfigured: Boolean(trunk.sipUser),
|
|
authUserConfigured: Boolean(trunk.authUser),
|
|
passwordConfigured: Boolean(trunk.password),
|
|
callerIdConfigured: Boolean(trunk.callerId),
|
|
}
|
|
}
|
|
|
|
return envExternalTelephonyConfig()
|
|
}
|
|
|
|
server.get("/telephony/config", async (req) => ({
|
|
enabled: telephonyEnabled(),
|
|
provider: "asterisk",
|
|
mode: "local-test",
|
|
sipDomain: sipDomain(),
|
|
sipWebSocketUrl: publicAsteriskWsUrl(),
|
|
echoExtension: process.env.TELEPHONY_ECHO_EXTENSION || "600",
|
|
testAccounts: testAccounts(),
|
|
external: await externalTelephonyConfig(req.user?.tenant_id || null),
|
|
}))
|
|
|
|
server.get("/telephony/status", async () => {
|
|
const enabled = telephonyEnabled()
|
|
const urls = asteriskHttpStatusUrls()
|
|
|
|
let lastError: any = null
|
|
const attempts = []
|
|
|
|
for (const url of urls) {
|
|
try {
|
|
const response = await fetchWithTimeout(url)
|
|
attempts.push({
|
|
url,
|
|
reachable: true,
|
|
statusCode: response.status,
|
|
})
|
|
|
|
return {
|
|
enabled,
|
|
provider: "asterisk",
|
|
reachable: true,
|
|
statusCode: response.status,
|
|
statusUrl: url,
|
|
attempts,
|
|
message: enabled
|
|
? (response.ok ? "Asterisk ist erreichbar." : `Asterisk-HTTP ist erreichbar (HTTP ${response.status}).`)
|
|
: "Asterisk ist erreichbar, Telefonie ist aber noch nicht aktiviert.",
|
|
}
|
|
} catch (error: any) {
|
|
lastError = error
|
|
attempts.push({
|
|
url,
|
|
reachable: false,
|
|
message: error?.name === "AbortError"
|
|
? "Abgelaufen"
|
|
: (error?.message || "Nicht erreichbar"),
|
|
})
|
|
}
|
|
}
|
|
|
|
return {
|
|
enabled,
|
|
provider: "asterisk",
|
|
reachable: false,
|
|
statusUrl: urls[0],
|
|
attempts,
|
|
message: lastError?.name === "AbortError"
|
|
? "Asterisk-Statusabfrage ist abgelaufen."
|
|
: (lastError?.message || "Asterisk ist nicht erreichbar."),
|
|
}
|
|
})
|
|
|
|
server.get("/telephony/trunk-config", async (req) => {
|
|
const tenantId = requireTenant(req.user.tenant_id)
|
|
const trunk = await loadTenantTrunk(tenantId)
|
|
|
|
return sanitizeTrunk(trunk)
|
|
})
|
|
|
|
server.put("/telephony/trunk-config", async (req, reply) => {
|
|
const tenantId = requireTenant(req.user.tenant_id)
|
|
const body = (req.body || {}) as any
|
|
const existing = await loadTenantTrunk(tenantId)
|
|
const password = bodyString(body, "password")
|
|
const clearPassword = body?.clearPassword === true
|
|
const now = new Date()
|
|
const values = {
|
|
tenantId,
|
|
provider: "telekom",
|
|
enabled: Boolean(body.enabled),
|
|
registrar: bodyString(body, "registrar") || "tel.t-online.de",
|
|
sipUser: bodyString(body, "sipUser"),
|
|
authUser: bodyString(body, "authUser"),
|
|
callerId: bodyString(body, "callerId"),
|
|
inboundExtension: bodyString(body, "inboundExtension") || "1001",
|
|
outboundPrefix: bodyString(body, "outboundPrefix") || "0",
|
|
externalSignalingAddress: bodyString(body, "externalSignalingAddress"),
|
|
externalMediaAddress: bodyString(body, "externalMediaAddress"),
|
|
localNetworks: bodyString(body, "localNetworks") || "172.16.0.0/12,192.168.0.0/16,10.0.0.0/8",
|
|
password: clearPassword ? null : (password || existing?.password || null),
|
|
updatedAt: now,
|
|
updatedBy: req.user.user_id,
|
|
}
|
|
|
|
if (values.enabled && (!values.sipUser || !values.password)) {
|
|
return reply.code(400).send({
|
|
error: "SIP-ID und Kennwort sind erforderlich, wenn der Trunk aktiviert wird.",
|
|
})
|
|
}
|
|
|
|
if (existing) {
|
|
const [updated] = await server.db
|
|
.update(telephonyTrunks)
|
|
.set(values)
|
|
.where(and(
|
|
eq(telephonyTrunks.tenantId, tenantId),
|
|
eq(telephonyTrunks.provider, "telekom")
|
|
))
|
|
.returning()
|
|
|
|
return sanitizeTrunk(updated)
|
|
}
|
|
|
|
const [created] = await server.db
|
|
.insert(telephonyTrunks)
|
|
.values({
|
|
...values,
|
|
createdAt: now,
|
|
createdBy: req.user.user_id,
|
|
})
|
|
.returning()
|
|
|
|
return sanitizeTrunk(created)
|
|
})
|
|
|
|
server.post("/telephony/trunk-config/apply", async (req, reply) => {
|
|
const tenantId = requireTenant(req.user.tenant_id)
|
|
const trunk = await loadTenantTrunk(tenantId)
|
|
|
|
if (!trunk) {
|
|
return reply.code(404).send({ error: "Telefonie-Trunk ist noch nicht konfiguriert." })
|
|
}
|
|
|
|
if (trunk.enabled && (!trunk.sipUser || !trunk.password)) {
|
|
return reply.code(400).send({
|
|
error: "SIP-ID und Kennwort sind erforderlich, bevor der Trunk angewendet werden kann.",
|
|
})
|
|
}
|
|
|
|
const files = await writeAsteriskTrunkConfig(trunk)
|
|
let reload: any = null
|
|
let status: any = null
|
|
let warning: string | null = null
|
|
|
|
try {
|
|
reload = await runAsteriskReload()
|
|
status = await readAsteriskTrunkStatus()
|
|
} catch (error: any) {
|
|
warning = error?.message || "Asterisk konnte nicht neu geladen werden."
|
|
}
|
|
|
|
return {
|
|
generated: true,
|
|
files,
|
|
trunk: sanitizeTrunk(trunk),
|
|
reload,
|
|
status,
|
|
warning,
|
|
}
|
|
})
|
|
|
|
server.get("/telephony/trunk-status", async (req, reply) => {
|
|
requireTenant(req.user.tenant_id)
|
|
|
|
try {
|
|
return await readAsteriskTrunkStatus()
|
|
} catch (error: any) {
|
|
return reply.code(200).send({
|
|
reachable: false,
|
|
registered: false,
|
|
hasRegistration: false,
|
|
registrations: "",
|
|
message: error?.message || "Asterisk-AMI ist nicht erreichbar.",
|
|
})
|
|
}
|
|
})
|
|
|
|
server.get("/telephony/calls", async (req) => {
|
|
const tenantId = requireTenant(req.user.tenant_id)
|
|
const limit = Math.min(
|
|
Math.max(Number((req.query as { limit?: string })?.limit || 25), 1),
|
|
100
|
|
)
|
|
|
|
return await server.db
|
|
.select()
|
|
.from(telephonyCalls)
|
|
.where(eq(telephonyCalls.tenantId, tenantId))
|
|
.orderBy(desc(telephonyCalls.startedAt))
|
|
.limit(limit)
|
|
})
|
|
|
|
server.post("/telephony/calls", async (req, reply) => {
|
|
const tenantId = requireTenant(req.user.tenant_id)
|
|
const body = (req.body || {}) as any
|
|
const now = new Date()
|
|
const startedAt = bodyDate(body, "startedAt") || now
|
|
const direction = bodyString(body, "direction") === "incoming" ? "incoming" : "outgoing"
|
|
const status = bodyString(body, "status") || (direction === "incoming" ? "ringing" : "dialing")
|
|
|
|
const [created] = await server.db
|
|
.insert(telephonyCalls)
|
|
.values({
|
|
tenantId,
|
|
direction,
|
|
status,
|
|
localExtension: bodyString(body, "localExtension"),
|
|
remoteNumber: bodyString(body, "remoteNumber"),
|
|
remoteDisplayName: bodyString(body, "remoteDisplayName"),
|
|
sipCallId: bodyString(body, "sipCallId"),
|
|
startedAt,
|
|
createdBy: req.user.user_id,
|
|
})
|
|
.returning()
|
|
|
|
return reply.code(201).send(created)
|
|
})
|
|
|
|
server.patch("/telephony/calls/:id", async (req, reply) => {
|
|
const tenantId = requireTenant(req.user.tenant_id)
|
|
const params = req.params as { id: string }
|
|
const body = (req.body || {}) as any
|
|
|
|
const [existing] = await server.db
|
|
.select()
|
|
.from(telephonyCalls)
|
|
.where(and(
|
|
eq(telephonyCalls.tenantId, tenantId),
|
|
eq(telephonyCalls.id, params.id)
|
|
))
|
|
.limit(1)
|
|
|
|
if (!existing) {
|
|
return reply.code(404).send({ error: "Anruf nicht gefunden" })
|
|
}
|
|
|
|
const answeredAt = bodyDate(body, "answeredAt")
|
|
const endedAt = bodyDate(body, "endedAt")
|
|
const startedAt = existing.startedAt ? new Date(existing.startedAt) : null
|
|
const computedDuration = endedAt
|
|
? durationSeconds(answeredAt || startedAt, endedAt)
|
|
: null
|
|
|
|
const [updated] = await server.db
|
|
.update(telephonyCalls)
|
|
.set({
|
|
status: bodyString(body, "status") || existing.status,
|
|
localExtension: bodyString(body, "localExtension") || existing.localExtension,
|
|
remoteNumber: bodyString(body, "remoteNumber") || existing.remoteNumber,
|
|
remoteDisplayName: bodyString(body, "remoteDisplayName") || existing.remoteDisplayName,
|
|
sipCallId: bodyString(body, "sipCallId") || existing.sipCallId,
|
|
answeredAt: answeredAt || existing.answeredAt,
|
|
endedAt: endedAt || existing.endedAt,
|
|
durationSeconds: computedDuration ?? existing.durationSeconds,
|
|
updatedAt: new Date(),
|
|
updatedBy: req.user.user_id,
|
|
})
|
|
.where(and(
|
|
eq(telephonyCalls.tenantId, tenantId),
|
|
eq(telephonyCalls.id, params.id)
|
|
))
|
|
.returning()
|
|
|
|
return updated
|
|
})
|
|
}
|