HeuJung
03cbb99196
route:cache 는 새 앱을 부팅해 라우트를 수집하고, 그 부팅의 확장 라우트 프로바이더는 DB 가 아니라 캐시된 활성 확장 목록을 읽는다. 그래서 rebuild 가 invalidate*StatusCache 보다 앞서면 방금 바뀐 상태가 빠진 채 라우트가 박제되고, 라우트 캐시에는 스캔 폴백이 없어 오류도 로그도 없이 404 가 된다. 무효화를 굽기 직전이 아니라 DB 상태 쓰기 직후로 올려, 같은 목록을 읽는 훅 매핑 캐시까지 함께 바로잡았다. update 경로는 Updating 전이 직후에 비우면 그 창의 오토로드 갱신이 확장을 비활성으로 판정하므로, 상태 복원 직후에 비운 뒤 훅 캐시를 다시 굽는다. 플러그인 라우트 프로바이더에는 활성 게이트가 없어 비활성 플러그인의 API 가 계속 응답했다. 화면·메뉴만 사라지고 기능은 살아 있는 상태였다. 모듈과 같은 기준을 적용했다. 실패 사유가 하위 계층에서 버려져 관리자 화면에 :error 자리표시자가 그대로 노출되던 문제도 고쳤다. 반환 경로를 깨지 않도록 배열 키 reason 과 뒤에 붙인 선택적 out 파라미터로 사유를 실어 올리고, 확장이 수명주기 훅에서 사유를 남길 수 있는 통로를 추가했다. 설치 경로의 광역 RuntimeException catch 는 도메인 예외로 좁혀 원본 키와 파라미터를 응답에 싣는다 — 상태코드 422 는 유지해 사용자 계약을 함께 바꾸지 않는다. 언어팩 화면은 프로덕션에서 예외 원문을 싣지 않는 것이 확정된 계약이므로, 자리를 일반 문구로 채우는 대신 치환 자리 자체를 제거했다. 원문은 종전대로 errors 통로를 거쳐 디버그 모드에서 도달한다.
1008 lines
36 KiB
PHP
1008 lines
36 KiB
PHP
<?php
|
|
|
|
namespace App\Services;
|
|
|
|
use App\Contracts\Extension\PluginManagerInterface;
|
|
use App\Contracts\Repositories\PluginRepositoryInterface;
|
|
use App\Enums\ExtensionStatus;
|
|
use App\Exceptions\PluginOperationException;
|
|
use App\Extension\Helpers\ChangelogParser;
|
|
use App\Extension\Helpers\EditorSpecAssembler;
|
|
use App\Extension\Helpers\GithubHelper;
|
|
use App\Extension\Helpers\ZipInstallHelper;
|
|
use App\Extension\HookManager;
|
|
use App\Extension\Vendor\VendorMode;
|
|
use Illuminate\Http\UploadedFile;
|
|
use Illuminate\Support\Facades\File;
|
|
use Illuminate\Validation\ValidationException;
|
|
|
|
class PluginService
|
|
{
|
|
/**
|
|
* 검색 가능한 필드 목록
|
|
*/
|
|
private const SEARCHABLE_FIELDS = ['name', 'identifier', 'description', 'vendor'];
|
|
|
|
public function __construct(
|
|
private PluginRepositoryInterface $pluginRepository,
|
|
private PluginManagerInterface $pluginManager
|
|
) {}
|
|
|
|
/**
|
|
* 활성화된 플러그인들의 identifier 목록을 반환합니다.
|
|
*
|
|
* @return array 활성화된 플러그인 identifier 배열
|
|
*/
|
|
public function getActivePluginIdentifiers(): array
|
|
{
|
|
return $this->pluginRepository->getActivePluginIdentifiers();
|
|
}
|
|
|
|
/**
|
|
* 모든 플러그인 목록을 조회합니다 (설치된 플러그인과 미설치 플러그인 포함).
|
|
*
|
|
* @return array 모든 플러그인 목록
|
|
*/
|
|
public function getAllPlugins(): array
|
|
{
|
|
// PluginManager 초기화
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
// 설치된 플러그인과 미설치 플러그인을 분리하여 반환
|
|
$installedPlugins = $this->pluginManager->getInstalledPluginsWithDetails();
|
|
$uninstalledPlugins = $this->pluginManager->getUninstalledPlugins();
|
|
|
|
return [
|
|
'installed' => array_values($installedPlugins),
|
|
'uninstalled' => array_values($uninstalledPlugins),
|
|
'total' => count($installedPlugins) + count($uninstalledPlugins),
|
|
];
|
|
}
|
|
|
|
/**
|
|
* 설치된 플러그인만 조회합니다.
|
|
*
|
|
* @return array 설치된 플러그인 목록
|
|
*/
|
|
public function getInstalledPluginsOnly(): array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return array_values($this->pluginManager->getInstalledPluginsWithDetails());
|
|
}
|
|
|
|
/**
|
|
* 미설치 플러그인만 조회합니다.
|
|
*
|
|
* @return array 미설치 플러그인 목록
|
|
*/
|
|
public function getUninstalledPluginsOnly(): array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return array_values($this->pluginManager->getUninstalledPlugins());
|
|
}
|
|
|
|
/**
|
|
* 특정 플러그인의 상세 정보를 조회합니다.
|
|
*
|
|
* @param string $pluginName 플러그인명
|
|
* @return array|null 플러그인 정보 또는 null
|
|
*/
|
|
public function getPluginInfo(string $pluginName): ?array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return $this->pluginManager->getPluginInfo($pluginName);
|
|
}
|
|
|
|
/**
|
|
* 플러그인 삭제 시 삭제될 데이터 정보를 조회합니다.
|
|
*
|
|
* @param string $pluginName 플러그인명
|
|
* @return array|null 삭제 정보 (테이블 목록, 스토리지 디렉토리 목록, 용량) 또는 null
|
|
*/
|
|
public function getPluginUninstallInfo(string $pluginName): ?array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return $this->pluginManager->getPluginUninstallInfo($pluginName);
|
|
}
|
|
|
|
/**
|
|
* 플러그인을 설치합니다 (before/after_install 훅 발화 + ValidationException 변환).
|
|
*
|
|
* @param string $pluginName 플러그인 식별자
|
|
* @param VendorMode $vendorMode vendor 설치 모드 (Auto/Composer/Bundled)
|
|
* @param bool $force Updating/Failed 등 진행 중 상태도 무시하고 강제 설치 여부
|
|
* @param string|null $failureReason 실패 시 사유가 담기는 out 파라미터 (성공 시 null)
|
|
* @return array|null 설치된 플러그인 정보 또는 설치 실패 시 null
|
|
*
|
|
* @throws ValidationException 플러그인 설치 실패 시
|
|
*/
|
|
public function installPlugin(
|
|
string $pluginName,
|
|
VendorMode $vendorMode = VendorMode::Auto,
|
|
bool $force = false,
|
|
?string &$failureReason = null,
|
|
): ?array {
|
|
$failureReason = null;
|
|
|
|
HookManager::doAction('core.plugins.before_install', $pluginName);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->installPlugin($pluginName, null, $vendorMode, $force, $failureReason);
|
|
|
|
if ($result) {
|
|
// 설치 후 플러그인 정보 반환
|
|
$pluginInfo = $this->pluginManager->getPluginInfo($pluginName);
|
|
|
|
HookManager::doAction('core.plugins.after_install', $pluginName, $pluginInfo);
|
|
|
|
return $pluginInfo;
|
|
}
|
|
|
|
return null;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.installation_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인을 활성화합니다 (before/after_activate 훅 발화 + ValidationException 변환).
|
|
*
|
|
* 의존성 미충족 등으로 경고 응답이 돌아오면 success/warning 형태 그대로 반환합니다.
|
|
*
|
|
* @param string $pluginName 플러그인 식별자
|
|
* @param bool $force 의존성 경고를 무시하고 강제 활성화 여부
|
|
* @return array{success: bool, plugin_info?: array, warning?: bool} 활성화 결과
|
|
*
|
|
* @throws ValidationException 활성화 실패 시
|
|
*/
|
|
public function activatePlugin(string $pluginName, bool $force = false): array
|
|
{
|
|
HookManager::doAction('core.plugins.before_activate', $pluginName);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->activatePlugin($pluginName, $force);
|
|
|
|
// 경고 응답인 경우 그대로 반환
|
|
if (isset($result['warning']) && $result['warning'] === true) {
|
|
return $result;
|
|
}
|
|
|
|
if ($result['success']) {
|
|
$pluginInfo = $this->pluginManager->getPluginInfo($pluginName);
|
|
|
|
HookManager::doAction('core.plugins.after_activate', $pluginName, $pluginInfo);
|
|
|
|
return [
|
|
'success' => true,
|
|
'plugin_info' => $pluginInfo,
|
|
];
|
|
}
|
|
|
|
// 실패 사유(reason)를 그대로 전달한다 — 여기서 떨어뜨리면 관리자 화면의
|
|
// 실패 문구에 원인 자리가 비어 자리표시자가 그대로 노출된다.
|
|
return $result;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.activation_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인을 비활성화합니다 (before/after_deactivate 훅 발화 + ValidationException 변환).
|
|
*
|
|
* 의존하는 다른 활성 확장이 있으면 경고 응답이 돌아오며 그대로 반환합니다.
|
|
*
|
|
* @param string $pluginName 플러그인 식별자
|
|
* @param bool $force 의존성 경고를 무시하고 강제 비활성화 여부
|
|
* @return array{success: bool, plugin_info?: array, warning?: bool} 비활성화 결과
|
|
*
|
|
* @throws ValidationException 비활성화 실패 시
|
|
*/
|
|
public function deactivatePlugin(string $pluginName, bool $force = false): array
|
|
{
|
|
HookManager::doAction('core.plugins.before_deactivate', $pluginName);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->deactivatePlugin($pluginName, $force);
|
|
|
|
// 경고 응답인 경우 그대로 반환
|
|
if (isset($result['warning']) && $result['warning'] === true) {
|
|
return $result;
|
|
}
|
|
|
|
if ($result['success']) {
|
|
$pluginInfo = $this->pluginManager->getPluginInfo($pluginName);
|
|
|
|
// after_deactivate 훅은 PluginManager 가 string identifier 시그니처로 이미 발화
|
|
// (Service 중복 발화 제거 — listener 2회 실행으로 인한 activity log 중복 차단)
|
|
|
|
return array_merge($result, ['plugin_info' => $pluginInfo]);
|
|
}
|
|
|
|
return $result;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.deactivation_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인을 제거합니다 (before/after_uninstall 훅 발화).
|
|
*
|
|
* @param string $pluginName 플러그인 식별자
|
|
* @param bool $deleteData 플러그인이 생성한 DB 데이터/스토리지 디렉토리까지 삭제 여부
|
|
* @param string|null $failureReason 실패 시 사유가 담기는 out 파라미터 (성공 시 null)
|
|
* @return bool 제거 성공 여부
|
|
*
|
|
* @throws ValidationException 제거 실패 시
|
|
*/
|
|
public function uninstallPlugin(string $pluginName, bool $deleteData = false, ?string &$failureReason = null): bool
|
|
{
|
|
$failureReason = null;
|
|
|
|
HookManager::doAction('core.plugins.before_uninstall', $pluginName, $deleteData);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
$result = $this->pluginManager->uninstallPlugin($pluginName, $deleteData, null, $failureReason);
|
|
|
|
HookManager::doAction('core.plugins.after_uninstall', $pluginName, $deleteData, $result);
|
|
|
|
return $result;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.uninstallation_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 페이지네이션 및 검색 필터가 적용된 플러그인 목록을 조회합니다.
|
|
*
|
|
* @param array $filters 검색 필터 (search, filters, status)
|
|
* @param int $perPage 페이지당 항목 수
|
|
* @param int $page 현재 페이지
|
|
* @return array 페이지네이션된 플러그인 목록
|
|
*/
|
|
public function getPaginatedPlugins(array $filters, int $perPage = 12, int $page = 1): array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
// 모든 플러그인 가져오기
|
|
$installedPlugins = $this->pluginManager->getInstalledPluginsWithDetails();
|
|
$uninstalledPlugins = $this->pluginManager->getUninstalledPlugins();
|
|
|
|
// 모든 플러그인 합치기
|
|
$allPlugins = array_merge(
|
|
array_values($installedPlugins),
|
|
array_values($uninstalledPlugins)
|
|
);
|
|
|
|
// 숨김 필터 적용 (기본: 숨김 항목 제외)
|
|
$allPlugins = $this->applyHiddenFilter($allPlugins, (bool) ($filters['include_hidden'] ?? false));
|
|
|
|
// 상태 필터 적용
|
|
if (! empty($filters['status'])) {
|
|
$allPlugins = $this->applyStatusFilter($allPlugins, $filters['status']);
|
|
}
|
|
|
|
// 다중 검색 필터 적용 (우선)
|
|
if (! empty($filters['filters']) && is_array($filters['filters'])) {
|
|
$allPlugins = $this->applyMultipleSearchFilters($allPlugins, $filters['filters']);
|
|
}
|
|
// 단일 검색어 필터 (하위 호환성)
|
|
elseif (! empty($filters['search'])) {
|
|
$allPlugins = $this->applyOrSearchAcrossFields($allPlugins, $filters['search']);
|
|
}
|
|
|
|
// 총 개수
|
|
$total = count($allPlugins);
|
|
|
|
// 페이지네이션 적용
|
|
$offset = ($page - 1) * $perPage;
|
|
$paginatedPlugins = array_slice($allPlugins, $offset, $perPage);
|
|
|
|
return [
|
|
'data' => array_values($paginatedPlugins),
|
|
'total' => $total,
|
|
'current_page' => $page,
|
|
'last_page' => (int) ceil($total / $perPage),
|
|
'per_page' => $perPage,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* 숨김 필터를 적용합니다.
|
|
*
|
|
* manifest 의 hidden=true 로 마킹된 플러그인은 기본 제외되며,
|
|
* $includeHidden=true 인 경우 포함됩니다.
|
|
*
|
|
* @param array $plugins 플러그인 목록
|
|
* @param bool $includeHidden 숨김 항목 포함 여부
|
|
* @return array 필터링된 플러그인 목록
|
|
*/
|
|
private function applyHiddenFilter(array $plugins, bool $includeHidden): array
|
|
{
|
|
if ($includeHidden) {
|
|
return $plugins;
|
|
}
|
|
|
|
return array_filter($plugins, function ($plugin) {
|
|
return empty($plugin['hidden']);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 상태 필터를 적용합니다.
|
|
*
|
|
* @param array $plugins 플러그인 목록
|
|
* @param string $status 상태 (installed, not_installed, active, inactive)
|
|
* @return array 필터링된 플러그인 목록
|
|
*/
|
|
private function applyStatusFilter(array $plugins, string $status): array
|
|
{
|
|
return array_filter($plugins, function ($plugin) use ($status) {
|
|
return match ($status) {
|
|
'installed' => ($plugin['status'] ?? '') !== 'uninstalled',
|
|
'uninstalled' => ($plugin['status'] ?? '') === 'uninstalled',
|
|
'active' => ($plugin['status'] ?? '') === 'active',
|
|
'inactive' => ($plugin['status'] ?? '') === 'inactive',
|
|
default => true,
|
|
};
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 다중 검색 조건을 적용합니다 (AND 조건).
|
|
*
|
|
* @param array $plugins 플러그인 목록
|
|
* @param array $searchFilters 검색 필터 배열
|
|
* @return array 필터링된 플러그인 목록
|
|
*/
|
|
private function applyMultipleSearchFilters(array $plugins, array $searchFilters): array
|
|
{
|
|
if (empty($searchFilters)) {
|
|
return $plugins;
|
|
}
|
|
|
|
return array_filter($plugins, function ($plugin) use ($searchFilters) {
|
|
foreach ($searchFilters as $filter) {
|
|
if (! $this->matchesFilter($plugin, $filter)) {
|
|
return false; // AND 조건: 하나라도 실패하면 제외
|
|
}
|
|
}
|
|
|
|
return true;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 단일 필터 조건 매칭 여부를 확인합니다.
|
|
*
|
|
* @param array $plugin 플러그인 정보
|
|
* @param array $filter 필터 조건
|
|
* @return bool 매칭 여부
|
|
*/
|
|
private function matchesFilter(array $plugin, array $filter): bool
|
|
{
|
|
$field = $filter['field'] ?? null;
|
|
$value = $filter['value'] ?? null;
|
|
$operator = $filter['operator'] ?? 'like';
|
|
|
|
if (! $field || ! $value || ! in_array($field, self::SEARCHABLE_FIELDS)) {
|
|
return true; // 유효하지 않은 필터는 통과
|
|
}
|
|
|
|
// 필드 값 가져오기 (다국어 필드 처리)
|
|
$fieldValue = $this->getFieldValue($plugin, $field);
|
|
|
|
if ($fieldValue === null) {
|
|
return false;
|
|
}
|
|
|
|
return match ($operator) {
|
|
'eq' => mb_strtolower($fieldValue) === mb_strtolower($value),
|
|
'starts_with' => str_starts_with(mb_strtolower($fieldValue), mb_strtolower($value)),
|
|
'ends_with' => str_ends_with(mb_strtolower($fieldValue), mb_strtolower($value)),
|
|
default => str_contains(mb_strtolower($fieldValue), mb_strtolower($value)), // like
|
|
};
|
|
}
|
|
|
|
/**
|
|
* 단일 검색어로 여러 필드를 OR 조건으로 검색합니다.
|
|
*
|
|
* @param array $plugins 플러그인 목록
|
|
* @param string $searchTerm 검색어
|
|
* @return array 필터링된 플러그인 목록
|
|
*/
|
|
private function applyOrSearchAcrossFields(array $plugins, string $searchTerm): array
|
|
{
|
|
$searchTerm = mb_strtolower($searchTerm);
|
|
|
|
return array_filter($plugins, function ($plugin) use ($searchTerm) {
|
|
foreach (self::SEARCHABLE_FIELDS as $field) {
|
|
$fieldValue = $this->getFieldValue($plugin, $field);
|
|
if ($fieldValue !== null && str_contains(mb_strtolower($fieldValue), $searchTerm)) {
|
|
return true; // OR 조건: 하나라도 매칭되면 포함
|
|
}
|
|
}
|
|
|
|
return false;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 플러그인에서 필드 값을 가져옵니다 (다국어 필드 처리 포함).
|
|
*
|
|
* @param array $plugin 플러그인 정보
|
|
* @param string $field 필드명
|
|
* @return string|null 필드 값
|
|
*/
|
|
private function getFieldValue(array $plugin, string $field): ?string
|
|
{
|
|
$value = $plugin[$field] ?? null;
|
|
|
|
if ($value === null) {
|
|
return null;
|
|
}
|
|
|
|
// 다국어 필드인 경우 (name, description)
|
|
if (is_array($value)) {
|
|
// 현재 로케일 우선, 없으면 ko, 그 다음 en
|
|
$locale = app()->getLocale();
|
|
|
|
return $value[$locale] ?? $value[config('app.fallback_locale', 'ko')] ?? reset($value) ?: null;
|
|
}
|
|
|
|
return (string) $value;
|
|
}
|
|
|
|
/**
|
|
* 설치된 플러그인들의 업데이트 가능 여부를 확인합니다.
|
|
*
|
|
* @return array 업데이트 확인 결과 (updated_count, details)
|
|
*
|
|
* @throws ValidationException 업데이트 확인 실패 시
|
|
*/
|
|
public function checkForUpdates(): array
|
|
{
|
|
HookManager::doAction('core.plugins.before_check_updates');
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->checkAllPluginsForUpdates();
|
|
|
|
HookManager::doAction('core.plugins.after_check_updates', $result);
|
|
|
|
return $result;
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugins' => [__('plugins.check_updates_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 지정된 플러그인을 업데이트합니다.
|
|
*
|
|
* @param string $pluginName 업데이트할 플러그인 identifier
|
|
* @param VendorMode $vendorMode Vendor 설치 모드
|
|
* @param string $layoutStrategy 레이아웃 전략 (overwrite|keep)
|
|
* @param bool $force 코어 버전 비호환 강제 우회 (위험 — 사용자 명시 필요)
|
|
* @return array 업데이트 결과 (identifier, from_version, to_version 등)
|
|
*
|
|
* @throws ValidationException 업데이트 실패 시
|
|
*/
|
|
public function updatePlugin(
|
|
string $pluginName,
|
|
VendorMode $vendorMode = VendorMode::Auto,
|
|
string $layoutStrategy = 'overwrite',
|
|
bool $force = false,
|
|
): array {
|
|
HookManager::doAction('core.plugins.before_update', $pluginName);
|
|
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->updatePlugin(
|
|
$pluginName,
|
|
$force,
|
|
null,
|
|
$vendorMode,
|
|
$layoutStrategy,
|
|
);
|
|
|
|
$pluginInfo = $this->pluginManager->getPluginInfo($pluginName);
|
|
|
|
HookManager::doAction('core.plugins.after_update', $pluginName, $result, $pluginInfo);
|
|
|
|
return array_merge($result, [
|
|
'plugin_info' => $pluginInfo,
|
|
]);
|
|
} catch (\Exception $e) {
|
|
// Manager의 RuntimeException은 이미 번역된 메시지를 포함하므로
|
|
// getPrevious()로 원본 에러를 추출하여 이중 래핑 방지
|
|
$rawError = $e->getPrevious() ? $e->getPrevious()->getMessage() : $e->getMessage();
|
|
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.errors.update_failed', ['plugin' => $pluginName, 'error' => $rawError])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 지정된 플러그인의 수정된 레이아웃을 확인합니다.
|
|
*
|
|
* @param string $pluginName 확인할 플러그인 identifier
|
|
* @return array{has_modified_layouts: bool, modified_count: int, modified_layouts: array}
|
|
*
|
|
* @throws ValidationException 확인 실패 시
|
|
*/
|
|
public function checkModifiedLayouts(string $pluginName): array
|
|
{
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return $this->pluginManager->hasModifiedLayouts($pluginName);
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.check_modified_layouts_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인의 레이아웃을 파일에서 다시 읽어 DB에 갱신합니다.
|
|
*
|
|
* @param string $pluginName 플러그인명
|
|
* @return array{success: bool, layouts_refreshed: int} 갱신 결과 및 갱신된 레이아웃 개수
|
|
*
|
|
* @throws ValidationException 플러그인을 찾을 수 없거나 갱신 실패 시
|
|
*/
|
|
public function refreshPluginLayouts(string $pluginName): array
|
|
{
|
|
try {
|
|
$this->pluginManager->loadPlugins();
|
|
|
|
return $this->pluginManager->refreshPluginLayouts($pluginName);
|
|
} catch (\Exception $e) {
|
|
throw ValidationException::withMessages([
|
|
'plugin_name' => [__('plugins.refresh_layouts_failed', ['error' => $e->getMessage()])],
|
|
]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인 에셋 파일 경로를 반환합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @param string $path 파일 경로
|
|
* @return array{success: bool, filePath: string|null, mimeType: string|null, error: string|null}
|
|
*/
|
|
public function getAssetFilePath(string $identifier, string $path): array
|
|
{
|
|
// 1. 활성화된 플러그인 확인
|
|
$plugin = $this->pluginRepository->findByIdentifier($identifier);
|
|
|
|
if (! $plugin || $plugin->status !== ExtensionStatus::Active->value) {
|
|
return [
|
|
'success' => false,
|
|
'filePath' => null,
|
|
'mimeType' => null,
|
|
'error' => 'plugin_not_found',
|
|
];
|
|
}
|
|
|
|
// 2. 파일 경로 구성 (플러그인 루트 기준)
|
|
$filePath = base_path("plugins/{$identifier}/{$path}");
|
|
|
|
// 3. 파일 존재 확인
|
|
if (! file_exists($filePath) || ! is_file($filePath)) {
|
|
return [
|
|
'success' => false,
|
|
'filePath' => null,
|
|
'mimeType' => null,
|
|
'error' => 'file_not_found',
|
|
];
|
|
}
|
|
|
|
// 4. MIME 타입 감지
|
|
$mimeType = $this->getMimeType($filePath);
|
|
|
|
return [
|
|
'success' => true,
|
|
'filePath' => $filePath,
|
|
'mimeType' => $mimeType,
|
|
'error' => null,
|
|
];
|
|
}
|
|
|
|
/**
|
|
* 플러그인 편집기 스펙(editor-spec.json) 디코드 결과를 반환합니다.
|
|
*
|
|
* 활성 플러그인만 대상으로 하며, 활성 디렉토리 → _bundled 폴백 순으로 읽습니다.
|
|
* editor-spec.json 은 수작업 작성 파일로 플러그인 루트(plugin.json 옆)에 둡니다.
|
|
* 파일 미존재/미작성 시 spec=null 로 폴백합니다(편집 컨트롤 부재).
|
|
*
|
|
* @param string $identifier 플러그인 식별자 (vendor-plugin 형식)
|
|
* @return array{success: bool, spec: array<string, mixed>|null, error: string|null}
|
|
*/
|
|
public function getEditorSpec(string $identifier): array
|
|
{
|
|
$plugin = $this->pluginRepository->findByIdentifier($identifier);
|
|
|
|
if (! $plugin || $plugin->status !== ExtensionStatus::Active->value) {
|
|
return ['success' => false, 'spec' => null, 'error' => 'plugin_not_found'];
|
|
}
|
|
|
|
// 분할 editor-spec.json 은 manifest + `$include` 블록으로 구성되므로
|
|
// 단순 디코드가 아닌 합본이 필요하다. 활성 디렉토리만 기준으로 합본한다
|
|
// (_bundled 폴백 없음). _bundled 작업분은 plugin:update 로 활성에
|
|
// 반영된 뒤에만 런타임에 보인다. 미분할 파일은 원본 그대로(하위 호환).
|
|
$spec = EditorSpecAssembler::assemble(
|
|
base_path("plugins/{$identifier}/editor-spec.json")
|
|
);
|
|
|
|
return ['success' => true, 'spec' => $spec, 'error' => null];
|
|
}
|
|
|
|
/**
|
|
* 플러그인 컴포넌트 매니페스트(components.json) 디코드 결과를 반환합니다.
|
|
*
|
|
* components.json 은 plugin:build 산출물로 플러그인 루트에 둡니다.
|
|
* 활성 디렉토리 → _bundled 폴백 순으로 읽으며, 미생성(구버전 플러그인) 시
|
|
* components=null 로 폴백합니다(무손실 보존 디그레이드 — 원칙 4.6).
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @return array{success: bool, components: array<string, mixed>|null, error: string|null}
|
|
*/
|
|
public function getComponents(string $identifier): array
|
|
{
|
|
$plugin = $this->pluginRepository->findByIdentifier($identifier);
|
|
|
|
if (! $plugin || $plugin->status !== ExtensionStatus::Active->value) {
|
|
return ['success' => false, 'components' => null, 'error' => 'plugin_not_found'];
|
|
}
|
|
|
|
$components = $this->readJsonWithBundledFallback("plugins/{$identifier}/components.json");
|
|
|
|
return ['success' => true, 'components' => $components, 'error' => null];
|
|
}
|
|
|
|
/**
|
|
* 활성 디렉토리 → _bundled 폴백 순으로 JSON 파일을 읽어 디코드합니다.
|
|
*
|
|
* @param string $relativePath base_path 기준 상대 경로 (plugins/{id}/file.json)
|
|
* @return array<string, mixed>|null 디코드된 배열, 미존재/파싱 실패 시 null
|
|
*/
|
|
private function readJsonWithBundledFallback(string $relativePath): ?array
|
|
{
|
|
$bundledPath = preg_replace('#^plugins/#', 'plugins/_bundled/', $relativePath, 1);
|
|
$candidates = [base_path($relativePath), base_path((string) $bundledPath)];
|
|
|
|
foreach ($candidates as $path) {
|
|
if (! file_exists($path) || ! is_file($path)) {
|
|
continue;
|
|
}
|
|
$decoded = json_decode((string) file_get_contents($path), true);
|
|
if (is_array($decoded)) {
|
|
return $decoded;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* MIME 타입 감지
|
|
*
|
|
* @param string $filePath 파일 경로
|
|
* @return string MIME 타입
|
|
*/
|
|
private function getMimeType(string $filePath): string
|
|
{
|
|
$mimeTypes = [
|
|
'js' => 'application/javascript',
|
|
'mjs' => 'application/javascript',
|
|
'css' => 'text/css',
|
|
'json' => 'application/json',
|
|
'png' => 'image/png',
|
|
'jpg' => 'image/jpeg',
|
|
'jpeg' => 'image/jpeg',
|
|
'svg' => 'image/svg+xml',
|
|
'webp' => 'image/webp',
|
|
'gif' => 'image/gif',
|
|
'ico' => 'image/x-icon',
|
|
'woff' => 'font/woff',
|
|
'woff2' => 'font/woff2',
|
|
'ttf' => 'font/ttf',
|
|
'otf' => 'font/otf',
|
|
'eot' => 'application/vnd.ms-fontobject',
|
|
];
|
|
|
|
$extension = strtolower(pathinfo($filePath, PATHINFO_EXTENSION));
|
|
|
|
return $mimeTypes[$extension] ?? 'application/octet-stream';
|
|
}
|
|
|
|
/**
|
|
* 플러그인의 변경 내역(changelog)을 조회합니다.
|
|
*
|
|
* source가 'github'이면 GitHub에서 원격 CHANGELOG.md를 가져와 파싱합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @param string|null $source 소스 ('active', 'bundled', 'github')
|
|
* @param string|null $fromVersion 시작 버전 (초과)
|
|
* @param string|null $toVersion 끝 버전 (이하)
|
|
* @return array 변경 내역 배열
|
|
*/
|
|
public function getPluginChangelog(string $identifier, ?string $source = null, ?string $fromVersion = null, ?string $toVersion = null): array
|
|
{
|
|
// GitHub 소스: 원격에서 CHANGELOG.md를 가져옴
|
|
if ($source === 'github') {
|
|
return $this->fetchRemoteChangelog($identifier, $fromVersion, $toVersion);
|
|
}
|
|
|
|
$basePath = base_path('plugins');
|
|
$filePath = ChangelogParser::resolveChangelogPath($basePath, $identifier, $source);
|
|
|
|
if ($filePath === null) {
|
|
return [];
|
|
}
|
|
|
|
if ($fromVersion !== null && $toVersion !== null) {
|
|
return ChangelogParser::getVersionRange($filePath, $fromVersion, $toVersion);
|
|
}
|
|
|
|
return ChangelogParser::parse($filePath);
|
|
}
|
|
|
|
/**
|
|
* GitHub에서 원격 CHANGELOG.md를 가져와 파싱합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @param string|null $fromVersion 시작 버전 (초과)
|
|
* @param string|null $toVersion 끝 버전 (이하)
|
|
* @return array 변경 내역 배열
|
|
*/
|
|
private function fetchRemoteChangelog(string $identifier, ?string $fromVersion = null, ?string $toVersion = null): array
|
|
{
|
|
$plugin = $this->pluginManager->getPlugin($identifier);
|
|
|
|
if (! $plugin) {
|
|
return [];
|
|
}
|
|
|
|
$githubUrl = $plugin->getGithubUrl();
|
|
|
|
if (empty($githubUrl)) {
|
|
return $this->getPluginChangelog($identifier, 'bundled', $fromVersion, $toVersion);
|
|
}
|
|
|
|
try {
|
|
[$owner, $repo] = GithubHelper::parseUrl($githubUrl);
|
|
} catch (\RuntimeException $e) {
|
|
return $this->getPluginChangelog($identifier, 'bundled', $fromVersion, $toVersion);
|
|
}
|
|
|
|
$ref = $toVersion ?? 'main';
|
|
$content = GithubHelper::fetchRawFile($owner, $repo, $ref, 'CHANGELOG.md');
|
|
|
|
if ($content === null) {
|
|
return $this->getPluginChangelog($identifier, 'bundled', $fromVersion, $toVersion);
|
|
}
|
|
|
|
if ($fromVersion !== null && $toVersion !== null) {
|
|
return ChangelogParser::getVersionRangeFromString($content, $fromVersion, $toVersion);
|
|
}
|
|
|
|
return ChangelogParser::parseFromString($content);
|
|
}
|
|
|
|
/**
|
|
* ZIP 파일에서 플러그인을 설치합니다.
|
|
*
|
|
* @param UploadedFile $file 업로드된 ZIP 파일
|
|
* @return array 설치된 플러그인 정보
|
|
*
|
|
* @throws \RuntimeException 설치 실패 시
|
|
*/
|
|
/**
|
|
* 업로드된 ZIP 의 manifest 와 검증 결과만 추출합니다 (실제 설치 X).
|
|
*
|
|
* 사용자가 플러그인 설치 전 plugin.json 검증 실패 사유를 미리 확인할 수 있게 합니다.
|
|
*
|
|
* @param UploadedFile $file 업로드된 ZIP 파일
|
|
* @return array{manifest: ?array<string, mixed>, validation: array<string, mixed>} 미리보기 결과
|
|
*/
|
|
public function previewManifest(UploadedFile $file): array
|
|
{
|
|
$tempPath = storage_path('app/temp/plugins');
|
|
$extractPath = $tempPath.'/preview-'.uniqid('plugin_');
|
|
$manifest = null;
|
|
$errors = [];
|
|
|
|
try {
|
|
File::ensureDirectoryExists($tempPath);
|
|
|
|
$result = ZipInstallHelper::extractAndValidate(
|
|
$file->getRealPath(), $extractPath, 'plugin.json', 'plugins'
|
|
);
|
|
|
|
$manifest = $result['config'];
|
|
} catch (\Throwable $e) {
|
|
$errors[] = $e->getMessage();
|
|
} finally {
|
|
if (File::exists($extractPath)) {
|
|
File::deleteDirectory($extractPath);
|
|
}
|
|
}
|
|
|
|
$existing = $manifest && ! empty($manifest['identifier'])
|
|
? $this->pluginRepository->findByIdentifier($manifest['identifier'])
|
|
: null;
|
|
|
|
return [
|
|
'manifest' => $manifest,
|
|
'validation' => [
|
|
'errors' => $errors,
|
|
'is_valid' => $errors === [] && $manifest !== null,
|
|
'already_installed' => $existing !== null,
|
|
'existing_version' => $existing?->version,
|
|
],
|
|
];
|
|
}
|
|
|
|
/**
|
|
* 업로드된 ZIP 파일로부터 플러그인을 추출/검증하고 _pending 으로 이동 후 설치합니다.
|
|
*
|
|
* `plugin.json` 검증 → identifier 충돌 검사 → _pending 이동 → 설치 파이프라인 진입.
|
|
*
|
|
* @param UploadedFile $file 사용자가 업로드한 플러그인 ZIP 파일
|
|
* @return array 설치 결과 (identifier/version/installed_at 포함)
|
|
*/
|
|
public function installFromZipFile(UploadedFile $file): array
|
|
{
|
|
$tempPath = storage_path('app/temp/plugins');
|
|
$extractPath = $tempPath.'/'.uniqid('plugin_');
|
|
|
|
try {
|
|
File::ensureDirectoryExists($tempPath);
|
|
|
|
$result = ZipInstallHelper::extractAndValidate(
|
|
$file->getRealPath(), $extractPath, 'plugin.json', 'plugins'
|
|
);
|
|
|
|
$this->ensurePluginNotInstalled($result['identifier']);
|
|
|
|
ZipInstallHelper::moveToPending(
|
|
$result['sourcePath'], base_path('plugins/_pending'), $result['identifier']
|
|
);
|
|
|
|
try {
|
|
return $this->executePluginInstall($result['identifier']);
|
|
} catch (\Throwable $e) {
|
|
$pendingPath = base_path('plugins/_pending/'.$result['identifier']);
|
|
if (File::exists($pendingPath)) {
|
|
File::deleteDirectory($pendingPath);
|
|
}
|
|
throw $e;
|
|
}
|
|
} finally {
|
|
if (File::exists($extractPath)) {
|
|
File::deleteDirectory($extractPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* GitHub 저장소에서 플러그인을 설치합니다.
|
|
*
|
|
* @param string $githubUrl GitHub 저장소 URL
|
|
* @return array 설치된 플러그인 정보
|
|
*
|
|
* @throws \RuntimeException 설치 실패 시
|
|
*/
|
|
public function installFromGithub(string $githubUrl): array
|
|
{
|
|
$tempPath = storage_path('app/temp/plugins');
|
|
$extractPath = $tempPath.'/'.uniqid('plugin_');
|
|
$zipPath = null;
|
|
|
|
try {
|
|
File::ensureDirectoryExists($tempPath);
|
|
|
|
[$owner, $repo] = GithubHelper::parseUrl($githubUrl);
|
|
|
|
$token = config('app.update.github_token') ?? '';
|
|
|
|
if (! GithubHelper::checkRepoExists($owner, $repo, $token)) {
|
|
throw new PluginOperationException('plugins.errors.github_repo_not_found');
|
|
}
|
|
|
|
$zipPath = GithubHelper::downloadZip($owner, $repo, $tempPath, $token);
|
|
|
|
$result = ZipInstallHelper::extractAndValidate(
|
|
$zipPath, $extractPath, 'plugin.json', 'plugins'
|
|
);
|
|
|
|
$this->ensurePluginNotInstalled($result['identifier']);
|
|
|
|
ZipInstallHelper::moveToPending(
|
|
$result['sourcePath'], base_path('plugins/_pending'), $result['identifier']
|
|
);
|
|
|
|
try {
|
|
return $this->executePluginInstall($result['identifier']);
|
|
} catch (\Throwable $e) {
|
|
$pendingPath = base_path('plugins/_pending/'.$result['identifier']);
|
|
if (File::exists($pendingPath)) {
|
|
File::deleteDirectory($pendingPath);
|
|
}
|
|
throw $e;
|
|
}
|
|
} finally {
|
|
if (File::exists($extractPath)) {
|
|
File::deleteDirectory($extractPath);
|
|
}
|
|
if ($zipPath && File::exists($zipPath)) {
|
|
File::delete($zipPath);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 플러그인이 이미 설치되어 있는지 확인합니다.
|
|
*
|
|
* _bundled/_pending에만 존재하는 경우(is_installed=false)는 설치 허용합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
*
|
|
* @throws \RuntimeException 이미 설치된 경우
|
|
*/
|
|
private function ensurePluginNotInstalled(string $identifier): void
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
$existingPlugin = $this->pluginManager->getPluginInfo($identifier);
|
|
|
|
if ($existingPlugin && $existingPlugin['is_installed']) {
|
|
throw new PluginOperationException('plugins.errors.already_installed', ['plugin' => $identifier]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* _pending에서 플러그인을 설치합니다.
|
|
*
|
|
* @param string $identifier 플러그인 식별자
|
|
* @return array 설치된 플러그인 정보
|
|
*
|
|
* @throws \RuntimeException 설치 실패 시
|
|
*/
|
|
private function executePluginInstall(string $identifier): array
|
|
{
|
|
$this->pluginManager->loadPlugins();
|
|
$result = $this->pluginManager->installPlugin($identifier, null, VendorMode::Auto, false, $failureReason);
|
|
|
|
if (! $result) {
|
|
// 사유를 실어 올리지 않으면 'plugins.errors.install_failed' 의 치환 자리가
|
|
// 비어 관리자 화면에 리터럴 ':error' 가 그대로 노출된다.
|
|
throw new PluginOperationException('plugins.errors.install_failed', [
|
|
'error' => $failureReason ?? __('plugins.errors.unknown_error'),
|
|
]);
|
|
}
|
|
|
|
return $this->pluginManager->getPluginInfo($identifier);
|
|
}
|
|
}
|