425 lines
14 KiB
PHP
425 lines
14 KiB
PHP
<?php
|
|
|
|
namespace App\Http\Controllers;
|
|
|
|
use App\Models\License;
|
|
use App\Support\ApiDataTransformer;
|
|
use Illuminate\Http\Request;
|
|
use Illuminate\Support\Facades\DB;
|
|
use Illuminate\Support\Facades\Storage;
|
|
use Inertia\Inertia;
|
|
|
|
class LicenseController extends Controller
|
|
{
|
|
/**
|
|
* Display a listing of the resource.
|
|
*
|
|
* Retrieves all licenses from the database, ordered by expiration date.
|
|
*
|
|
* @return array
|
|
*/
|
|
public function index()
|
|
{
|
|
$licenses = License::orderBy('expirationDate', 'asc')->get();
|
|
|
|
return array_map(function (License $license) {
|
|
$licenseData = ApiDataTransformer::snakeToCamel($license->toArray());
|
|
$licenseData['validationInfo'] = $this->buildValidationInfo($licenseData);
|
|
|
|
return $licenseData;
|
|
}, $licenses->all());
|
|
}
|
|
|
|
/**
|
|
* Display the specified resource.
|
|
*
|
|
* Retrieves a single license by its ID.
|
|
*
|
|
* @param int $id The ID of the license to retrieve
|
|
* @return array
|
|
*/
|
|
public function single($id)
|
|
{
|
|
$license = License::findOrFail($id);
|
|
$licenseData = ApiDataTransformer::snakeToCamel($license->toArray());
|
|
$licenseData['validationInfo'] = $this->buildValidationInfo($licenseData);
|
|
|
|
return $licenseData;
|
|
}
|
|
|
|
/**
|
|
* Display the specified resource.
|
|
*
|
|
* Renders the Inertia view for licenses
|
|
*
|
|
* @return \Inertia\Response
|
|
*/
|
|
public function show()
|
|
{
|
|
return Inertia::render(
|
|
'Licenses',
|
|
['licenseData' => $this->index()]
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Get the directory path for license keys.
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function licenseKeyDirectory(): string
|
|
{
|
|
return 'license-keys';
|
|
}
|
|
|
|
/**
|
|
* Get the path for the private key file.
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function privateKeyPath(): string
|
|
{
|
|
return $this->licenseKeyDirectory() . '/private.pem';
|
|
}
|
|
|
|
/**
|
|
* Get the path for the public key file.
|
|
*
|
|
* @return string
|
|
*/
|
|
protected function publicKeyPath(): string
|
|
{
|
|
return $this->licenseKeyDirectory() . '/public.pem';
|
|
}
|
|
|
|
/**
|
|
* Get the application's key pair.
|
|
*
|
|
* @return array
|
|
*/
|
|
protected function getApplicationKeyPair(): array
|
|
{
|
|
if (!Storage::disk('local')->exists($this->privateKeyPath()) || !Storage::disk('local')->exists($this->publicKeyPath())) {
|
|
abort(500, 'Application license key pair is missing. Generate it with `php artisan license:generate-keys`.');
|
|
}
|
|
|
|
return [
|
|
'privateKey' => Storage::disk('local')->get($this->privateKeyPath()),
|
|
'publicKey' => Storage::disk('local')->get($this->publicKeyPath()),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Generate a signature for the license data.
|
|
*
|
|
* The payload is signed in camelCase because the signature is consumed by PHP-side
|
|
* validation logic and is not persisted as a database column shape.
|
|
*
|
|
* @param array $licenseData The license data to sign
|
|
* @param string $privateKey The private key to use for signing
|
|
* @return string
|
|
*/
|
|
protected function sign($licenseData, $privateKey)
|
|
{
|
|
$licenseJson = json_encode($licenseData);
|
|
if ($licenseJson === false) throw new \Exception('Fehler beim JSON-Encode der Lizenzdaten: ' . json_last_error_msg());
|
|
|
|
$success = openssl_sign($licenseJson, $signature, $privateKey, OPENSSL_ALGO_SHA256);
|
|
if ($success === false) throw new \Exception('Fehler beim Signieren der Lizenzdaten: ' . openssl_error_string());
|
|
|
|
return base64_encode($signature);
|
|
}
|
|
|
|
/**
|
|
* Store a newly created resource in storage.
|
|
*
|
|
* Validates the request data, generates a signature, and creates a new license.
|
|
*
|
|
* @param \Illuminate\Http\Request $request The HTTP request containing license data
|
|
* @return array
|
|
*/
|
|
public function store(Request $request)
|
|
{
|
|
// Validate the request data coming from the frontend in camelCase.
|
|
$validatedData = $request->validate([
|
|
'name' => 'required|string',
|
|
'email' => 'required|email',
|
|
'product' => 'required|string',
|
|
'version' => 'required|string',
|
|
'isPerpetual' => 'required|boolean',
|
|
'expirationDate' => 'nullable|date',
|
|
]);
|
|
|
|
|
|
$keyPair = $this->getApplicationKeyPair();
|
|
|
|
// Sign the camelCase business payload. The signature is validated by PHP code,
|
|
// not persisted as part of the database column schema.
|
|
$signatureData = [
|
|
'name' => $validatedData['name'],
|
|
'email' => $validatedData['email'],
|
|
'product' => $validatedData['product'],
|
|
'version' => $validatedData['version'],
|
|
'isPerpetual' => $validatedData['isPerpetual'],
|
|
'expirationDate' => $validatedData['isPerpetual'] ? null : $validatedData['expirationDate'],
|
|
];
|
|
|
|
$signature = $this->sign($signatureData, $keyPair['privateKey']);
|
|
|
|
// Convert incoming camelCase fields to snake_case only for database storage.
|
|
$snakeCaseData = ApiDataTransformer::camelToSnake($validatedData);
|
|
|
|
$license = License::create([
|
|
'name' => $snakeCaseData['name'],
|
|
'email' => $snakeCaseData['email'],
|
|
'product' => $snakeCaseData['product'],
|
|
'version' => $snakeCaseData['version'],
|
|
'is_perpetual' => $snakeCaseData['is_perpetual'],
|
|
'expiration_date' => $snakeCaseData['expiration_date'],
|
|
'signature' => $signature,
|
|
]);
|
|
|
|
return ApiDataTransformer::snakeToCamel($license->toArray());
|
|
}
|
|
|
|
|
|
/**
|
|
* Validate the license signature and expiration date.
|
|
*
|
|
* @param \Illuminate\Http\Request $request The HTTP request containing the license data
|
|
* @return array
|
|
*/
|
|
public function validate(Request $request)
|
|
{
|
|
// The frontend sends camelCase, and the signature is verified against the same
|
|
// camelCase representation. We keep snake_case only for database persistence.
|
|
$validatedData = $request->validate([
|
|
'name' => 'required|string',
|
|
'email' => 'required|email',
|
|
'product' => 'required|string',
|
|
'version' => 'required|string',
|
|
'isPerpetual' => 'required|boolean',
|
|
'expirationDate' => 'nullable|date',
|
|
'signature' => 'required|string',
|
|
]);
|
|
|
|
return $this->buildValidationInfo($validatedData);
|
|
}
|
|
|
|
|
|
/**
|
|
* Build the validation info for a license payload.
|
|
*
|
|
* A license is considered valid when:
|
|
* - the signature is valid, and
|
|
* - the license is perpetual, or the expiration date is still in the future.
|
|
*
|
|
* @param array $licenseData The license data to validate
|
|
* @return array
|
|
*/
|
|
protected function buildValidationInfo(array $licenseData): array
|
|
{
|
|
$publicKey = Storage::disk('local')->get($this->publicKeyPath());
|
|
|
|
$licenseData = ApiDataTransformer::snakeToCamel($licenseData);
|
|
$isPerpetual = (bool) ($licenseData['isPerpetual'] ?? false);
|
|
$expirationDate = $licenseData['expirationDate'] ?? null;
|
|
|
|
// Validate against the same camelCase payload shape used to generate the signature.
|
|
$licenseJson = json_encode([
|
|
'name' => $licenseData['name'] ?? '',
|
|
'email' => $licenseData['email'] ?? '',
|
|
'product' => $licenseData['product'] ?? '',
|
|
'version' => $licenseData['version'] ?? '',
|
|
'isPerpetual' => $isPerpetual,
|
|
'expirationDate' => $expirationDate,
|
|
]);
|
|
|
|
$signature = base64_decode($licenseData['signature'] ?? '', true);
|
|
$isSignatureValid = $signature !== false && openssl_verify($licenseJson, $signature, $publicKey, OPENSSL_ALGO_SHA256) === 1;
|
|
$isExpired = !$isPerpetual && !empty($expirationDate) && now()->gt($expirationDate);
|
|
|
|
return [
|
|
'isValid' => $isSignatureValid && !$isExpired,
|
|
'isSignatureValid' => $isSignatureValid,
|
|
'isExpired' => $isExpired,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* Download the license as a JSON file.
|
|
*
|
|
* @param int $id The ID of the license to download
|
|
* @return \Symfony\Component\HttpFoundation\StreamedResponse
|
|
*/
|
|
public function download(int $id)
|
|
{
|
|
// Find the license
|
|
$license = License::findOrFail($id);
|
|
|
|
// Prepare the license data for download
|
|
$licenseData = [
|
|
'name' => $license->name,
|
|
'email' => $license->email,
|
|
'product' => $license->product,
|
|
'version' => $license->version,
|
|
'is_perpetual' => $license->is_perpetual,
|
|
'expiration_date' => $license->expiration_date?->format('Y-m-d'),
|
|
'signature' => $license->signature,
|
|
];
|
|
|
|
// Normalize the outgoing payload to camelCase for the frontend consumer.
|
|
$licenseJson = json_encode(ApiDataTransformer::snakeToCamel($licenseData), JSON_PRETTY_PRINT);
|
|
|
|
// Create a response with the JSON file
|
|
$response = response($licenseJson, 200, [
|
|
'Content-Type' => 'application/json',
|
|
'Content-Disposition' => 'attachment; filename="' . $licenseData['product'] . '.license"',
|
|
]);
|
|
|
|
return $response;
|
|
}
|
|
|
|
/**
|
|
* Persist a single license update using the shared business logic.
|
|
*
|
|
* @param array $data The validated license payload in camelCase
|
|
* @param int $id The license id
|
|
* @param string $privateKey The application private key used to sign the payload
|
|
* @return array
|
|
*/
|
|
protected function persistLicenseUpdate(array $data, int $id, string $privateKey): array
|
|
{
|
|
$data['expirationDate'] = $data['isPerpetual'] ? null : $data['expirationDate'];
|
|
|
|
$signatureData = [
|
|
'name' => $data['name'],
|
|
'email' => $data['email'],
|
|
'product' => $data['product'],
|
|
'version' => $data['version'],
|
|
'isPerpetual' => $data['isPerpetual'],
|
|
'expirationDate' => $data['expirationDate'],
|
|
];
|
|
|
|
$signature = $this->sign($signatureData, $privateKey);
|
|
$snakeCaseData = ApiDataTransformer::camelToSnake($data);
|
|
|
|
$license = License::findOrFail($id);
|
|
$license->update([
|
|
'name' => $snakeCaseData['name'],
|
|
'email' => $snakeCaseData['email'],
|
|
'product' => $snakeCaseData['product'],
|
|
'version' => $snakeCaseData['version'],
|
|
'is_perpetual' => $snakeCaseData['is_perpetual'],
|
|
'expiration_date' => $snakeCaseData['expiration_date'],
|
|
'signature' => $signature,
|
|
]);
|
|
|
|
$licenseData = ApiDataTransformer::snakeToCamel($license->fresh()->toArray());
|
|
$licenseData['validationInfo'] = $this->buildValidationInfo($licenseData);
|
|
|
|
return $licenseData;
|
|
}
|
|
|
|
/**
|
|
* Update multiple licenses in a single request.
|
|
*
|
|
* This keeps the database writes in one HTTP request and avoids SQLite lock contention
|
|
* that can happen when a page sends one update request per dirty license in parallel.
|
|
*
|
|
* @param \Illuminate\Http\Request $request The HTTP request containing multiple updated license records
|
|
* @return array|\Illuminate\Http\JsonResponse
|
|
*/
|
|
public function updateMany(Request $request)
|
|
{
|
|
$validatedData = $request->validate([
|
|
'*.id' => 'required|integer',
|
|
'*.name' => 'required|string',
|
|
'*.email' => 'required|email',
|
|
'*.product' => 'required|string',
|
|
'*.version' => 'required|string',
|
|
'*.isPerpetual' => 'required|boolean',
|
|
'*.expirationDate' => 'nullable|date',
|
|
]);
|
|
|
|
$privateKey = $this->getApplicationKeyPair()['privateKey'];
|
|
|
|
DB::beginTransaction();
|
|
|
|
try {
|
|
$updatedLicenses = [];
|
|
|
|
foreach ($validatedData as $licensePayload) {
|
|
$updatedLicenses[] = $this->persistLicenseUpdate($licensePayload, $licensePayload['id'], $privateKey);
|
|
}
|
|
|
|
DB::commit();
|
|
|
|
return $updatedLicenses;
|
|
} catch (\Exception $e) {
|
|
DB::rollBack();
|
|
return response()->json([
|
|
'message' => 'Lizenzen konnten nicht aktualisiert werden',
|
|
'error' => $e->getMessage()
|
|
], 500);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Update the specified resource in storage.
|
|
*
|
|
* Validates the request data, generates a new signature, and updates the license.
|
|
*
|
|
* @param \Illuminate\Http\Request $request The HTTP request containing updated license data
|
|
* @param int $id The ID of the license to update
|
|
* @return array|\Illuminate\Http\JsonResponse
|
|
*/
|
|
public function update(Request $request, int $id)
|
|
{
|
|
// Validate the request data coming from the frontend in camelCase.
|
|
$validatedData = $request->validate([
|
|
'name' => 'required|string',
|
|
'email' => 'required|email',
|
|
'product' => 'required|string',
|
|
'version' => 'required|string',
|
|
'isPerpetual' => 'required|boolean',
|
|
'expirationDate' => 'nullable|date',
|
|
]);
|
|
|
|
DB::beginTransaction();
|
|
|
|
try {
|
|
$privateKey = $this->getApplicationKeyPair()['privateKey'];
|
|
$licenseData = $this->persistLicenseUpdate($validatedData, $id, $privateKey);
|
|
|
|
DB::commit();
|
|
|
|
// Return the updated license with its validation info attached.
|
|
return $licenseData;
|
|
} catch (\Exception $e) {
|
|
DB::rollBack();
|
|
return response()->json([
|
|
'message' => 'Lizenz konnte nicht aktualisiert werden',
|
|
'error' => $e->getMessage()
|
|
], 500);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Remove the specified resource from storage.
|
|
*
|
|
* Deletes the specified license from the database.
|
|
*
|
|
* @param int $id The ID of the license to delete
|
|
* @return \Illuminate\Http\JsonResponse
|
|
*/
|
|
public function destroy(int $id)
|
|
{
|
|
$license = License::findOrFail($id);
|
|
$license->delete();
|
|
return response()->json([
|
|
'message' => 'Lizenz erfolgreich gelöscht'
|
|
]);
|
|
}
|
|
}
|