kevin/KeyHelp-Manager-for-WHMCS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

commit update

Browse Source
This commit is contained in:
Kevin Feiler
2025-10-15 22:40:34 +02:00
parent 351da5fe19
commit 8259ec4621
2 changed files with 513 additions and 632 deletions
Download Patch File Download Diff File Expand all files Collapse all files

511
modules/servers/keyhelpmanager/keyhelpmanager.php
View File

@@ -1,23 +1,12 @@
<?php
/**
* WHMCS KeyHelp Manager Provisioning Module
* KeyHelp Manager - WHMCS Provisioning Module
*
* @author Kevin Feiler <info@avvgo.de>
* @copyright Copyright (c) 2024 Kevin Feiler / AVVGO
* @license MIT License
* @link https://avvgo.de
* @version 1.0.0
*
* Dieses Modul ermöglicht die automatische Verwaltung von KeyHelp-Hosting-Accounts
* direkt aus WHMCS heraus. Es unterstützt Erstellung, Sperrung, Entsperrung und
* Löschung von Accounts sowie die Anzeige von Account-Informationen im Client-Bereich.
*
* Entwickelt von Kevin Feiler / AVVGO
*
* Kompatibel mit:
* - PHP 8.3+
* - WHMCS 8.13+
* - KeyHelp (neueste stabile Version)
*/
if (!defined("WHMCS")) {
@@ -26,13 +15,6 @@ if (!defined("WHMCS")) {
use WHMCS\Database\Capsule;
/**
* Modul-Metadaten
*
* Definiert die grundlegenden Informationen über das Modul.
*
* @return array Modul-Metadaten
*/
function keyhelpmanager_MetaData()
{
return [
@@ -41,18 +23,11 @@ function keyhelpmanager_MetaData()
"RequiresServer" => true,
"DefaultNonSSLPort" => "80",
"DefaultSSLPort" => "443",
"ServiceSingleSignOnLabel" => "Login zu KeyHelp",
"AdminSingleSignOnLabel" => "Als Admin einloggen",
"ServiceSingleSignOnLabel" => "Login to KeyHelp",
"AdminSingleSignOnLabel" => "Login as Admin",
];
}
/**
* Modul-Konfigurationsoptionen
*
* Definiert die Felder, die in der Server-Konfiguration in WHMCS angezeigt werden.
*
* @return array Konfigurations-Array
*/
function keyhelpmanager_ConfigOptions()
{
return [
@@ -60,48 +35,32 @@ function keyhelpmanager_ConfigOptions()
"FriendlyName" => "Hostname (IP or FQDN)",
"Type" => "text",
"Size" => "25",
"Default" => "",
"Description" =>
"Hostname oder IP-Adresse deines KeyHelp-Servers (ohne http:// oder https://)",
"KeyHelp server hostname or IP address (without http://)",
"Required" => true,
],
"apikey" => [
"FriendlyName" => "API Key",
"Type" => "password",
"Size" => "50",
"Default" => "",
"Description" =>
"Dein KeyHelp API-Schlüssel (zu finden in KeyHelp unter Einstellungen → API)",
"Description" => "KeyHelp API Key from Settings → API",
"Required" => true,
],
"usessl" => [
"FriendlyName" => "Use SSL",
"Type" => "yesno",
"Default" => "on",
"Description" =>
"SSL für die Verbindung zur API verwenden (dringend empfohlen)",
"Description" => "Use SSL for API connection (recommended)",
],
"verify_ssl" => [
"FriendlyName" => "Verify SSL Certificate",
"Type" => "yesno",
"Default" => "on",
"Description" =>
"SSL-Zertifikat verifizieren (bei selbstsignierten Zertifikaten deaktivieren)",
"Description" => "Verify SSL certificate (disable for self-signed)",
],
];
}
/**
* API-Request Hilfsfunktion
*
* Sendet HTTP-Anfragen an die KeyHelp-API und verarbeitet die Antworten.
*
* @param array $params WHMCS-Parameter-Array
* @param string $endpoint API-Endpunkt (z.B. '/users', '/users/123')
* @param string $method HTTP-Methode (GET, POST, PUT, DELETE)
* @param array $data Request-Body-Daten
* @return array Ergebnis mit 'success' (bool) und 'data' oder 'error'
*/
function _keyhelpmanager_APIRequest(
array $params,
string $endpoint,
@@ -109,43 +68,28 @@ function _keyhelpmanager_APIRequest(
array $data = [],
) {
try {
// Konfiguration auslesen
$hostname =
$params["serverhostname"] ?? ($params["configoption1"] ?? "");
$apiKey = $params["serverpassword"] ?? ($params["configoption2"] ?? "");
$useSSL = $params["configoption3"] ?? "on";
$verifySSL = $params["configoption4"] ?? "on";
// Validierung
if (empty($hostname)) {
if (empty($hostname) || empty($apiKey)) {
return [
"success" => false,
"error" => "KeyHelp-Hostname ist nicht konfiguriert.",
"error" => "KeyHelp server not configured",
];
}
if (empty($apiKey)) {
return [
"success" => false,
"error" => "KeyHelp API-Schlüssel ist nicht konfiguriert.",
];
}
// Protocol bestimmen
$protocol = $useSSL === "on" ? "https" : "http";
$url = sprintf("%s://%s/api/v2%s", $protocol, $hostname, $endpoint);
// Basis-URL zusammenbauen
$baseUrl = sprintf("%s://%s/api/v2", $protocol, $hostname);
$url = $baseUrl . $endpoint;
// Guzzle HTTP-Client initialisieren
$client = new \GuzzleHttp\Client([
"verify" => $verifySSL === "on",
"timeout" => 30,
"http_errors" => false,
]);
// Request-Optionen
$options = [
"headers" => [
"X-API-Key" => $apiKey,
@@ -154,30 +98,24 @@ function _keyhelpmanager_APIRequest(
],
];
// Body-Daten hinzufügen wenn vorhanden
if (!empty($data) && in_array($method, ["POST", "PUT", "PATCH"])) {
$options["json"] = $data;
}
// API-Request ausführen
$response = $client->request($method, $url, $options);
$statusCode = $response->getStatusCode();
$body = (string) $response->getBody();
// JSON-Antwort dekodieren
$responseData = json_decode($body, true);
// Logging für Debugging
logModuleCall(
"keyhelpmanager",
$method . " " . $endpoint,
$data,
$statusCode . " - " . $body,
$responseData,
[$apiKey], // API-Key in Logs maskieren
[$apiKey],
);
// Erfolgreiche Antworten (2xx)
if ($statusCode >= 200 && $statusCode < 300) {
return [
"success" => true,
@@ -186,91 +124,58 @@ function _keyhelpmanager_APIRequest(
];
}
// Fehlerbehandlung
$errorMessage = "KeyHelp API-Fehler: ";
if (isset($responseData["message"])) {
$errorMessage .= $responseData["message"];
} elseif (isset($responseData["error"])) {
$errorMessage .= $responseData["error"];
} else {
$errorMessage .= sprintf("HTTP Status %d - %s", $statusCode, $body);
}
$errorMessage =
$responseData["message"] ??
($responseData["error"] ??
sprintf("HTTP %d - %s", $statusCode, $body));
return [
"success" => false,
"error" => $errorMessage,
"error" => "KeyHelp API Error: " . $errorMessage,
"status_code" => $statusCode,
];
} catch (\GuzzleHttp\Exception\ConnectException $e) {
return [
"success" => false,
"error" =>
"Verbindung zum KeyHelp-Server fehlgeschlagen: " .
$e->getMessage(),
];
} catch (\GuzzleHttp\Exception\RequestException $e) {
return [
"success" => false,
"error" => "API-Request fehlgeschlagen: " . $e->getMessage(),
"error" => "Connection failed: " . $e->getMessage(),
];
} catch (\Exception $e) {
return [
"success" => false,
"error" => "Unerwarteter Fehler: " . $e->getMessage(),
'
success' => false,
"error" => "Unexpected error: " . $e->getMessage(),
];
}
}
/**
* Account erstellen
*
* Wird von WHMCS nach erfolgreicher Bezahlung aufgerufen.
* Erstellt einen neuen Benutzer-Account in KeyHelp.
*
* @param array $params WHMCS-Parameter
* @return string Erfolgs- oder Fehlermeldung
*/
function keyhelpmanager_CreateAccount(array $params)
{
try {
// Extrahiere notwendige Parameter
$domain = $params["domain"] ?? "";
$username = $params["username"] ?? "";
$password = $params["password"] ?? "";
$username =
$params["username"] ?? _keyhelpmanager_GenerateUsername($domain);
$password = $params["password"] ?? _keyhelpmanager_GeneratePassword();
$clientEmail = $params["clientsdetails"]["email"] ?? "";
$firstName = $params["clientsdetails"]["firstname"] ?? "";
$lastName = $params["clientsdetails"]["lastname"] ?? "";
$clientName = trim(
($params["clientsdetails"]["firstname"] ?? "") .
" " .
($params["clientsdetails"]["lastname"] ?? ""),
);
// Validierung
if (empty($domain)) {
return "Domain ist erforderlich.";
return "Domain is required";
}
if (empty($username)) {
// Generiere Benutzernamen aus Domain wenn nicht vorhanden
$username = _keyhelpmanager_GenerateUsername($domain);
}
if (empty($password)) {
// Generiere sicheres Passwort wenn nicht vorhanden
$password = _keyhelpmanager_GeneratePassword();
}
// Account-Daten für KeyHelp API vorbereiten
$accountData = [
"login_name" => $username,
"password" => $password,
"email" => $clientEmail,
"display_name" => trim($firstName . " " . $lastName),
"display_name" => $clientName,
];
// Optional: Plan/Tarif aus konfigurierbaren Optionen
if (!empty($params["configoptions"]["KeyHelp Plan"])) {
$accountData["plan"] = $params["configoptions"]["KeyHelp Plan"];
}
// Benutzer über API erstellen
$result = _keyhelpmanager_APIRequest(
$params,
"/users",
@@ -285,15 +190,10 @@ function keyhelpmanager_CreateAccount(array $params)
$userId = $result["data"]["id"] ?? null;
if (empty($userId)) {
return "Benutzer wurde erstellt, aber keine User-ID zurückgegeben.";
return "User created but no ID returned";
}
// Domain zum Benutzer hinzufügen
$domainData = [
"domain_name" => $domain,
"user_id" => $userId,
];
$domainData = ["domain_name" => $domain, "user_id" => $userId];
$domainResult = _keyhelpmanager_APIRequest(
$params,
"/domains",
@@ -302,13 +202,10 @@ function keyhelpmanager_CreateAccount(array $params)
);
if (!$domainResult["success"]) {
// Rollback: Benutzer wieder löschen
_keyhelpmanager_APIRequest($params, "/users/" . $userId, "DELETE");
return "Domain konnte nicht hinzugefügt werden: " .
$domainResult["error"];
return "Domain creation failed: " . $domainResult["error"];
}
// Speichere Username und Passwort in WHMCS Custom Fields
_keyhelpmanager_SaveAccountDetails($params["serviceid"], [
"username" => $username,
"password" => $password,
@@ -317,137 +214,80 @@ function keyhelpmanager_CreateAccount(array $params)
return "success";
} catch (\Exception $e) {
return "Fehler beim Erstellen des Accounts: " . $e->getMessage();
return "Account creation failed: " . $e->getMessage();
}
}
/**
* Account sperren
*
* Wird von WHMCS aufgerufen, wenn ein Account gesperrt werden soll
* (z.B. bei Zahlungsverzug).
*
* @param array $params WHMCS-Parameter
* @return string Erfolgs- oder Fehlermeldung
*/
function keyhelpmanager_SuspendAccount(array $params)
{
try {
$userId = _keyhelpmanager_GetUserId($params);
if (empty($userId)) {
return "Benutzer-ID nicht gefunden. Account wurde möglicherweise nicht korrekt erstellt.";
return "User ID not found";
}
// Benutzer-Status auf "gesperrt" setzen
$updateData = [
"is_locked" => true,
];
$result = _keyhelpmanager_APIRequest(
$params,
"/users/" . $userId,
"PUT",
$updateData,
["is_locked" => true],
);
if (!$result["success"]) {
return $result["error"];
}
return "success";
return $result["success"] ? "success" : $result["error"];
} catch (\Exception $e) {
return "Fehler beim Sperren des Accounts: " . $e->getMessage();
return "Suspend failed: " . $e->getMessage();
}
}
/**
* Account entsperren
*
* Wird von WHMCS aufgerufen, wenn ein gesperrter Account wieder
* aktiviert werden soll.
*
* @param array $params WHMCS-Parameter
* @return string Erfolgs- oder Fehlermeldung
*/
function keyhelpmanager_UnsuspendAccount(array $params)
{
try {
$userId = _keyhelpmanager_GetUserId($params);
if (empty($userId)) {
return "Benutzer-ID nicht gefunden. Account wurde möglicherweise nicht korrekt erstellt.";
return "User ID not found";
}
// Benutzer-Status auf "aktiv" setzen
$updateData = [
"is_locked" => false,
];
$result = _keyhelpmanager_APIRequest(
$params,
"/users/" . $userId,
"PUT",
$updateData,
["is_locked" => false],
);
if (!$result["success"]) {
return $result["error"];
}
return "success";
return $result["success"] ? "success" : $result["error"];
} catch (\Exception $e) {
return "Fehler beim Entsperren des Accounts: " . $e->getMessage();
return "Unsuspend failed: " . $e->getMessage();
}
}
/**
* Account löschen
*
* Wird von WHMCS aufgerufen, wenn ein Account endgültig gelöscht werden soll.
* ACHTUNG: Dies löscht alle Daten unwiderruflich!
*
* @param array $params WHMCS-Parameter
* @return string Erfolgs- oder Fehlermeldung
*/
function keyhelpmanager_TerminateAccount(array $params)
{
try {
$userId = _keyhelpmanager_GetUserId($params);
if (empty($userId)) {
return "Benutzer-ID nicht gefunden. Account wurde möglicherweise bereits gelöscht.";
return "User ID not found";
}
// Benutzer und alle zugehörigen Daten löschen
$result = _keyhelpmanager_APIRequest(
$params,
"/users/" . $userId,
"DELETE",
);
if (!$result["success"]) {
return $result["error"];
if ($result["success"]) {
_keyhelpmanager_DeleteAccountDetails($params["serviceid"]);
return "success";
}
// Entferne gespeicherte Account-Details
_keyhelpmanager_DeleteAccountDetails($params["serviceid"]);
return "success";
return $result["error"];
} catch (\Exception $e) {
return "Fehler beim Löschen des Accounts: " . $e->getMessage();
return "Termination failed: " . $e->getMessage();
}
}
/**
* Client-Bereich
*
* Gibt Informationen für den Client-Bereich in WHMCS zurück.
* Zeigt Login-Details und Hosting-Statistiken an.
*
* @param array $params WHMCS-Parameter
* @return array Template-Variablen
*/
function keyhelpmanager_ClientArea(array $params)
{
try {
@@ -455,30 +295,24 @@ function keyhelpmanager_ClientArea(array $params)
$params["serviceid"],
);
$userId = $accountDetails["userid"] ?? null;
$hostname =
$params["serverhostname"] ?? ($params["configoption1"] ?? "");
$useSSL = $params["configoption3"] ?? "on";
$protocol = $useSSL === "on" ? "https" : "http";
// Login-URL
$loginUrl = sprintf("%s://%s", $protocol, $hostname);
// Basis-Informationen
$templateVars = [
"login_url" => $loginUrl,
"username" =>
$accountDetails["username"] ??
($params["username"] ?? "Nicht verfügbar"),
$accountDetails["username"] ?? ($params["username"] ?? "N/A"),
"password" =>
$accountDetails["password"] ??
($params["password"] ?? "••••••••"),
"domain" => $params["domain"] ?? "Nicht verfügbar",
"stats" => [],
"domain" => $params["domain"] ?? "N/A",
"stats" => null,
"error" => null,
];
// Statistiken von KeyHelp API abrufen wenn User-ID vorhanden
if (!empty($userId)) {
$statsResult = _keyhelpmanager_APIRequest(
$params,
@@ -490,20 +324,24 @@ function keyhelpmanager_ClientArea(array $params)
$stats = $statsResult["data"];
$templateVars["stats"] = [
"disk_used" => _keyhelpmanager_FormatBytes(
"disk_used" => $stats["disk_usage"] ?? 0,
"disk_limit" => $stats["disk_limit"] ?? 0,
"disk_used_formatted" => _keyhelpmanager_FormatBytes(
$stats["disk_usage"] ?? 0,
),
"disk_limit" => _keyhelpmanager_FormatBytes(
"disk_limit_formatted" => _keyhelpmanager_FormatBytes(
$stats["disk_limit"] ?? 0,
),
"disk_percent" => _keyhelpmanager_CalculatePercent(
$stats["disk_usage"] ?? 0,
$stats["disk_limit"] ?? 0,
),
"bandwidth_used" => _keyhelpmanager_FormatBytes(
"bandwidth_used" => $stats["traffic_usage"] ?? 0,
"bandwidth_limit" => $stats["traffic_limit"] ?? 0,
"bandwidth_used_formatted" => _keyhelpmanager_FormatBytes(
$stats["traffic_usage"] ?? 0,
),
"bandwidth_limit" => _keyhelpmanager_FormatBytes(
"bandwidth_limit_formatted" => _keyhelpmanager_FormatBytes(
$stats["traffic_limit"] ?? 0,
),
"bandwidth_percent" => _keyhelpmanager_CalculatePercent(
@@ -517,31 +355,18 @@ function keyhelpmanager_ClientArea(array $params)
}
}
return [
"templatefile" => "clientarea",
"vars" => $templateVars,
];
return ["templatefile" => "clientarea", "vars" => $templateVars];
} catch (\Exception $e) {
return [
"templatefile" => "clientarea",
"vars" => [
"error" =>
"Fehler beim Laden der Account-Informationen: " .
$e->getMessage(),
"Failed to load account information: " . $e->getMessage(),
],
];
}
}
/**
* Admin-Login-Link (Single Sign-On)
*
* Erstellt einen direkten Login-Link für Admins, um sich im KeyHelp-Panel
* des Kunden anzumelden, ohne das Passwort eingeben zu müssen.
*
* @param array $params WHMCS-Parameter
* @return array Login-Link-Konfiguration
*/
function keyhelpmanager_LoginLink(array $params)
{
try {
@@ -551,18 +376,10 @@ function keyhelpmanager_LoginLink(array $params)
$userId = $accountDetails["userid"] ?? null;
if (empty($userId)) {
return [
"success" => false,
"errorMsg" => "Benutzer-ID nicht gefunden.",
];
return ["success" => false, "errorMsg" => "User ID not found"];
}
// Session-Token von KeyHelp API anfordern
$sessionData = [
"user_id" => $userId,
"lifetime" => 300, // 5 Minuten Gültigkeit
];
$sessionData = ["user_id" => $userId, "lifetime" => 300];
$result = _keyhelpmanager_APIRequest(
$params,
"/sessions",
@@ -573,9 +390,7 @@ function keyhelpmanager_LoginLink(array $params)
if (!$result["success"]) {
return [
"success" => false,
"errorMsg" =>
"Login-Session konnte nicht erstellt werden: " .
$result["error"],
"errorMsg" => "Session creation failed: " . $result["error"],
];
}
@@ -584,16 +399,14 @@ function keyhelpmanager_LoginLink(array $params)
if (empty($sessionToken)) {
return [
"success" => false,
"errorMsg" => "Kein Session-Token erhalten.",
"errorMsg" => "No session token received",
];
}
// Login-URL mit Session-Token
$hostname =
$params["serverhostname"] ?? ($params["configoption1"] ?? "");
$useSSL = $params["configoption3"] ?? "on";
$protocol = $useSSL === "on" ? "https" : "http";
$loginUrl = sprintf(
"%s://%s/login?token=%s",
$protocol,
@@ -601,27 +414,15 @@ function keyhelpmanager_LoginLink(array $params)
$sessionToken,
);
return [
"success" => true,
"redirectTo" => $loginUrl,
];
return ["success" => true, "redirectTo" => $loginUrl];
} catch (\Exception $e) {
return [
"success" => false,
"errorMsg" =>
"Fehler beim Erstellen des Login-Links: " . $e->getMessage(),
"errorMsg" => "Login link creation failed: " . $e->getMessage(),
];
}
}
/**
* Passwort ändern
*
* Ermöglicht das Ändern des Passworts für einen KeyHelp-Account.
*
* @param array $params WHMCS-Parameter
* @return string Erfolgs- oder Fehlermeldung
*/
function keyhelpmanager_ChangePassword(array $params)
{
try {
@@ -629,101 +430,66 @@ function keyhelpmanager_ChangePassword(array $params)
$newPassword = $params["password"] ?? "";
if (empty($userId)) {
return "Benutzer-ID nicht gefunden.";
return "User ID not found";
}
if (empty($newPassword)) {
return "Neues Passwort ist erforderlich.";
return "New password is required";
}
// Passwort über API ändern
$updateData = [
"password" => $newPassword,
];
$result = _keyhelpmanager_APIRequest(
$params,
"/users/" . $userId,
"PUT",
$updateData,
["password" => $newPassword],
);
if (!$result["success"]) {
return $result["error"];
if ($result["success"]) {
_keyhelpmanager_UpdateAccountDetail(
$params["serviceid"],
"password",
$newPassword,
);
return "success";
}
// Aktualisiere gespeichertes Passwort
_keyhelpmanager_UpdateAccountDetail(
$params["serviceid"],
"password",
$newPassword,
);
return "success";
return $result["error"];
} catch (\Exception $e) {
return "Fehler beim Ändern des Passworts: " . $e->getMessage();
return "Password change failed: " . $e->getMessage();
}
}
/**
* Test-Verbindung
*
* Testet die Verbindung zur KeyHelp-API.
*
* @param array $params WHMCS-Parameter
* @return array Test-Ergebnis
*/
function keyhelpmanager_TestConnection(array $params)
{
try {
// Einfache API-Abfrage zum Testen
$result = _keyhelpmanager_APIRequest($params, "/server/version", "GET");
if (!$result["success"]) {
return [
"success" => false,
"error" => $result["error"],
];
return ["success" => false, "error" => $result["error"]];
}
$version = $result["data"]["version"] ?? "Unbekannt";
$version = $result["data"]["version"] ?? "Unknown";
return [
"success" => true,
"message" => sprintf(
"Verbindung erfolgreich! KeyHelp Version: %s",
"Connection successful! KeyHelp Version: %s",
$version,
),
];
} catch (\Exception $e) {
return [
"success" => false,
"error" => $e->getMessage(),
];
return ["success" => false, "error" => $e->getMessage()];
}
}
// ============================================================================
// HILFSFUNKTIONEN
// ============================================================================
// Helper Functions
/**
* Generiert einen sicheren Benutzernamen aus einer Domain
*
* @param string $domain Domain-Name
* @return string Generierter Benutzername
*/
function _keyhelpmanager_GenerateUsername(string $domain): string
{
// Entferne TLD und Sonderzeichen
$username = preg_replace('/\.[^.]+$/', "", $domain);
$username = preg_replace("/[^a-z0-9]/i", "", $username);
$username = strtolower($username);
$username = strtolower(substr($username, 0, 16));
// Begrenze auf 16 Zeichen
$username = substr($username, 0, 16);
// Füge zufällige Zahlen hinzu wenn zu kurz
if (strlen($username) < 6) {
$username .= rand(1000, 9999);
}
@@ -731,12 +497,6 @@ function _keyhelpmanager_GenerateUsername(string $domain): string
return $username;
}
/**
* Generiert ein sicheres Zufallspasswort
*
* @param int $length Passwort-Länge
* @return string Generiertes Passwort
*/
function _keyhelpmanager_GeneratePassword(int $length = 16): string
{
$chars =
@@ -751,27 +511,19 @@ function _keyhelpmanager_GeneratePassword(int $length = 16): string
return $password;
}
/**
* Speichert Account-Details in der WHMCS-Datenbank
*
* @param int $serviceId Service-ID
* @param array $details Account-Details (username, password, userid)
* @return void
*/
function _keyhelpmanager_SaveAccountDetails(
int $serviceId,
array $details,
): void {
try {
foreach ($details as $key => $value) {
Capsule::table("tblhosting")
->where("id", $serviceId)
->update([
$key === "username" ? "username" : "password" => $value,
]);
if ($key === "username" || $key === "password") {
Capsule::table("tblhosting")
->where("id", $serviceId)
->update([$key => $value]);
}
}
// Speichere userid in Custom Field oder Service Properties
if (isset($details["userid"])) {
Capsule::table("tblcustomfieldsvalues")->updateOrInsert(
[
@@ -780,32 +532,22 @@ function _keyhelpmanager_SaveAccountDetails(
"KeyHelp User ID",
),
],
[
"value" => $details["userid"],
],
["value" => $details["userid"]],
);
}
} catch (\Exception $e) {
logActivity(
"KeyHelpManager: Fehler beim Speichern der Account-Details: " .
$e->getMessage(),
"KeyHelpManager: Save account details failed - " . $e->getMessage(),
);
}
}
/**
* Lädt Account-Details aus der WHMCS-Datenbank
*
* @param int $serviceId Service-ID
* @return array Account-Details
*/
function _keyhelpmanager_GetAccountDetails(int $serviceId): array
{
try {
$service = Capsule::table("tblhosting")
->where("id", $serviceId)
->first();
$userid = Capsule::table("tblcustomfieldsvalues")
->where("relid", $serviceId)
->where(
@@ -821,33 +563,18 @@ function _keyhelpmanager_GetAccountDetails(int $serviceId): array
];
} catch (\Exception $e) {
logActivity(
"KeyHelpManager: Fehler beim Laden der Account-Details: " .
$e->getMessage(),
"KeyHelpManager: Get account details failed - " . $e->getMessage(),
);
return [];
}
}
/**
* Holt die KeyHelp User-ID für einen Service
*
* @param array $params WHMCS-Parameter
* @return int|null User-ID oder null
*/
function _keyhelpmanager_GetUserId(array $params): ?int
{
$accountDetails = _keyhelpmanager_GetAccountDetails($params["serviceid"]);
return $accountDetails["userid"] ?? null;
}
/**
* Aktualisiert ein einzelnes Account-Detail
*
* @param int $serviceId Service-ID
* @param string $field Feldname
* @param string $value Wert
* @return void
*/
function _keyhelpmanager_UpdateAccountDetail(
int $serviceId,
string $field,
@@ -857,26 +584,16 @@ function _keyhelpmanager_UpdateAccountDetail(
if ($field === "username" || $field === "password") {
Capsule::table("tblhosting")
->where("id", $serviceId)
->update([
$field => $value,
]);
->update([$field => $value]);
}
} catch (\Exception $e) {
logActivity(
"KeyHelpManager: Fehler beim Aktualisieren von " .
$field .
": " .
"KeyHelpManager: Update account detail failed - " .
$e->getMessage(),
);
}
}
/**
* Löscht gespeicherte Account-Details
*
* @param int $serviceId Service-ID
* @return void
*/
function _keyhelpmanager_DeleteAccountDetails(int $serviceId): void
{
try {
@@ -885,18 +602,12 @@ function _keyhelpmanager_DeleteAccountDetails(int $serviceId): void
->delete();
} catch (\Exception $e) {
logActivity(
"KeyHelpManager: Fehler beim Löschen der Account-Details: " .
"KeyHelpManager: Delete account details failed - " .
$e->getMessage(),
);
}
}
/**
* Holt oder erstellt die Custom Field ID für ein Feld
*
* @param string $fieldName Feldname
* @return int Field-ID
*/
function _keyhelpmanager_GetCustomFieldId(string $fieldName): int
{
try {
@@ -906,56 +617,34 @@ function _keyhelpmanager_GetCustomFieldId(string $fieldName): int
->first();
if (!$field) {
// Erstelle Custom Field wenn nicht vorhanden
$fieldId = Capsule::table("tblcustomfields")->insertGetId([
return Capsule::table("tblcustomfields")->insertGetId([
"type" => "product",
"fieldname" => $fieldName,
"fieldtype" => "text",
"description" => "",
"adminonly" => "on",
]);
return $fieldId;
}
return $field->id;
} catch (\Exception $e) {
logActivity(
"KeyHelpManager: Fehler beim Abrufen der Custom Field ID: " .
$e->getMessage(),
"KeyHelpManager: Get custom field ID failed - " . $e->getMessage(),
);
return 0;
}
}
/**
* Formatiert Bytes in eine lesbare Größe
*
* @param int $bytes Bytes
* @return string Formatierte Größe
*/
function _keyhelpmanager_FormatBytes(int $bytes): string
{
$units = ["B", "KB", "MB", "GB", "TB"];
$power = $bytes > 0 ? floor(log($bytes, 1024)) : 0;
return number_format($bytes / pow(1024, $power), 2, ",", ".") .
return number_format($bytes / pow(1024, $power), 2, ".", ",") .
" " .
$units[$power];
}
/**
* Berechnet Prozentsatz
*
* @param int $used Verbrauchter Wert
* @param int $limit Limit
* @return float Prozentsatz
*/
function _keyhelpmanager_CalculatePercent(int $used, int $limit): float
{
if ($limit == 0) {
return 0;
}
return round(($used / $limit) * 100, 2);
return $limit > 0 ? round(($used / $limit) * 100, 2) : 0;
}