��JFIF��2� /home/forge/crm-staging.pigment.se/app/Livewire/Monitor/ Current File: /home/forge/crm-staging.pigment.se/app/Livewire/Monitor/Credentials.php
<?php
/**
 * SSH Credentials Management Component
 *
 * Purpose:
 * - Manages SSH credentials for Kinsta-hosted sites
 * - Displays A records and connection status
 * - Handles SSH command and password storage
 *
 * View Location:
 * - resources/views/livewire/monitor/settings/credentials.blade.php
 *
 * URL Path:
 * - /monitor/credentials
 *
 * Navigation:
 * - Located under "4. Credentials" in the monitor navigation
 *
 * Related Models:
 * - KinstaSyncSite (for Kinsta connection status)
 * - Client (for CRM client names)
 * - Site (for domain relationships)
 *
 * Features:
 * - SSH credential management
 * - A Records display
 * - Connection status tracking
 * - Search functionality for sites/domains
 * - Bulk SSH key management
 */
namespace App\Livewire\Monitor;

use App\Models\KinstaSyncSite;
use Livewire\Component;
use App\Services\WordPressCliServiceSSH;
use Illuminate\Support\Facades\Crypt;
use Illuminate\Support\Facades\Log;
use Illuminate\Validation\ValidationException;
use App\Services\ClientTraverseService;

class Credentials extends Component
{
    public $search = '';
    public $activeTab = 'ssh';
    public $showAddSSH = false;
    public $showAddAPI = false;
    public $selectedSiteId = null;
    public $ssh_command = '';
    public $ssh_password = '';
    public $ssh_host = '';
    public $ssh_username = '';
    public $ssh_port = '';
    public $editingSiteId = [];
    public $inputs = [];

    private ClientTraverseService $clientService;

    protected $queryString = [
        'search' => ['except' => '']
    ];

    protected $rules = [
        'ssh_command' => ['required', 'string', 'regex:/^ssh\s+[^@]+@[^\s]+\s+-p\s+\d+$/'],
        'ssh_password' => 'required|string'
    ];

    protected $messages = [
        'inputs.*.ssh_command.required' => 'SSH command is required',
        'inputs.*.ssh_command.regex' => 'SSH command must be in format: ssh username@host -p port',
        'inputs.*.ssh_password.required' => 'SSH password is required'
    ];

    public function mount(ClientTraverseService $clientService)
    {
        $this->clientService = $clientService;

        // Initialize empty inputs for all sites
        $sites = KinstaSyncSite::all();
        foreach ($sites as $site) {
            if (!$site->ssh_username) {
                $this->inputs[$site->id] = [
                    'ssh_command' => '',
                    'ssh_password' => ''
                ];
            }
        }
    }

    public function editSite($siteId)
    {
        Log::info('Editing site credentials', [
            'site_id' => $siteId,
            'user_id' => auth()->id(),
            'timestamp' => now()
        ]);

        try {
            $this->editingSiteId[$siteId] = true;
            $site = KinstaSyncSite::findOrFail($siteId);

            // Initialize inputs for this site
            $this->inputs[$siteId] = [
                'ssh_command' => "ssh {$site->ssh_username}@{$site->ssh_host} -p {$site->ssh_port}",
                'ssh_password' => $site->ssh_password ? Crypt::decryptString($site->ssh_password) : '',
                'wp_path' => $site->wp_path
            ];

            Log::info('Site credentials loaded successfully', [
                'site_id' => $siteId,
                'site_name' => $site->kinsta_name
            ]);
        } catch (\Exception $e) {
            Log::error('Failed to load site credentials', [
                'site_id' => $siteId,
                'error' => $e->getMessage()
            ]);

            $this->dispatch('notify', [
                'message' => 'Failed to load site credentials',
                'type' => 'error'
            ]);
        }
    }

    public function resetForm()
    {
        $this->selectedSiteId = null;
        $this->ssh_command = '';
        $this->ssh_password = '';
    }

    public function updatedSshCommand()
    {
        try {
            if (preg_match('/ssh\s+([^@]+)@([^\s]+)\s+-p\s+(\d+)/', $this->ssh_command, $matches)) {
                $this->ssh_username = $matches[1];
                $this->ssh_host = $matches[2];
                $this->ssh_port = $matches[3];

                Log::info('SSH command parsed successfully', [
                    'username' => $this->ssh_username,
                    'host' => $this->ssh_host,
                    'port' => $this->ssh_port
                ]);
            }
        } catch (\Exception $e) {
            Log::error('Failed to parse SSH command', [
                'command' => $this->ssh_command,
                'error' => $e->getMessage()
            ]);
        }
    }

    public function saveCredentials($siteId)
    {
        Log::info('Attempting to save credentials', [
            'site_id' => $siteId,
            'user_id' => auth()->id(),
            'inputs' => $this->inputs[$siteId] ?? 'no inputs'  // Log the inputs
        ]);

        try {
            // Validate with more detailed error catching
            $validated = $this->validate([
                "inputs.{$siteId}.ssh_command" => [
                    'required',
                    'string',
                    'regex:/^ssh\s+[^@]+@[^\s]+\s+-p\s+\d+$/'
                ],
                "inputs.{$siteId}.ssh_password" => 'required|string'
            ], [
                "inputs.{$siteId}.ssh_command.required" => 'SSH command is required.',
                "inputs.{$siteId}.ssh_command.regex" => 'SSH command must be in format: ssh username@host -p port',
                "inputs.{$siteId}.ssh_password.required" => 'SSH password is required.'
            ]);

            Log::info('Validation passed', [
                'validated_data' => $validated
            ]);

            $site = KinstaSyncSite::findOrFail($siteId);

            // Parse SSH command
            preg_match('/ssh\s+([^@]+)@([^\s]+)\s+-p\s+(\d+)/', $this->inputs[$siteId]['ssh_command'], $matches);

            // Update site with new credentials and always set wp_path to "public"
            $site->update([
                'ssh_username' => $matches[1],
                'ssh_host' => $matches[2],
                'ssh_port' => $matches[3],
                'ssh_password' => Crypt::encryptString($this->inputs[$siteId]['ssh_password']),
                'wp_path' => 'public'  // Always set to "public"
            ]);

            Log::info('Credentials saved successfully', [
                'site_id' => $siteId,
                'site_name' => $site->kinsta_name,
                'wp_path' => 'public'
            ]);

            // Clear inputs and editing state
            unset($this->inputs[$siteId]);
            unset($this->editingSiteId[$siteId]);

            // Force a fresh query to get updated data
            $site->refresh();

            // Set placeholder values for the saved site
            $this->inputs[$siteId] = [
                'ssh_command' => '••••••••',
                'ssh_password' => '••••••••'
            ];

            $this->dispatch('notify', [
                'message' => 'SSH credentials saved successfully',
                'type' => 'success'
            ]);
        } catch (ValidationException $e) {
            Log::error('Validation failed', [
                'errors' => $e->errors(),
                'site_id' => $siteId
            ]);

            // Re-throw to ensure Livewire handles the validation errors
            throw $e;
        } catch (\Exception $e) {
            Log::error('Other error during save', [
                'error' => $e->getMessage(),
                'site_id' => $siteId
            ]);

            $this->dispatch('notify', [
                'message' => 'Failed to save credentials: ' . $e->getMessage(),
                'type' => 'error'
            ]);
        }
    }

    public function testConnection($siteId)
    {
        Log::info('Testing SSH connection', [
            'site_id' => $siteId,
            'user_id' => auth()->id()
        ]);

        try {
            $site = KinstaSyncSite::findOrFail($siteId);
            $result = app(WordPressCliServiceSSH::class)->testSiteConnection($site);

            Log::info('SSH connection test result', [
                'site_id' => $siteId,
                'site_name' => $site->kinsta_name,
                'result' => $result
            ]);

            if ($result['connection'] === 'successful') {
                $this->dispatch('notify', ['message' => 'Connection successful!']);
            } else {
                $this->dispatch('notify', [
                    'message' => 'Connection failed: ' . $result['error'],
                    'type' => 'error'
                ]);
            }
        } catch (\Exception $e) {
            Log::error('SSH connection test failed', [
                'site_id' => $siteId,
                'error' => $e->getMessage(),
                'trace' => $e->getTraceAsString()
            ]);

            $this->dispatch('notify', [
                'message' => 'Connection test failed: ' . $e->getMessage(),
                'type' => 'error'
            ]);
        }
    }

    public function render()
    {
        $searchTerm = $this->search;

        $query = KinstaSyncSite::query()
            ->whereNull('deleted_at')
            ->whereNotNull('domain_id')
            ->whereNotNull('kinsta_id')
            ->when($searchTerm, function ($query) use ($searchTerm) {
                $query->where(function ($q) use ($searchTerm) {
                    $q->where('kinsta_name', 'like', '%' . $searchTerm . '%')
                      ->orWhere('kinsta_primary_domain', 'like', '%' . $searchTerm . '%')
                      ->orWhereHas('domain', function ($q) use ($searchTerm) {
                          $q->where('domain', 'like', '%' . $searchTerm . '%');
                      })
                      ->orWhereHas('domain.site.client', function ($q) use ($searchTerm) {
                          $q->where('name', 'like', '%' . $searchTerm . '%');
                      });
                });
            })
            ->orderBy('kinsta_name');

        $sites = $query->get();

        return view('livewire.monitor.settings.credentials', [
            'sites' => $sites
        ]);
    }

    public function getDisplayCommand($site)
    {
        // If we're editing this site, return empty to allow input
        if (isset($this->editingSiteId[$site->id])) {
            return '';
        }

        // If site has credentials, show dots
        if ($site->ssh_username && $site->ssh_host && $site->ssh_port) {
            return '••••••••';
        }

        // Otherwise return empty
        return '';
    }

    public function getDisplayPassword($site)
    {
        // If we're editing this site, return empty to allow input
        if (isset($this->editingSiteId[$site->id])) {
            return '';
        }

        // If site has password, show dots
        if ($site->ssh_password) {
            return '••••••••';
        }

        // Otherwise return empty
        return '';
    }

    public function getARecords($site)
    {
        if (!$site->siteDnsLookup || !$site->siteDnsLookup->domain_id) {
            return null;
        }

        try {
            $records = json_decode($site->siteDnsLookup->domain_a_records, true);
            if (!$records) {
                return null;
            }

            return collect($records)->pluck('ip')->join(', ');
        } catch (\Exception $e) {
            Log::error('Error parsing A records', [
                'site_id' => $site->id,
                'error' => $e->getMessage()
            ]);
            return null;
        }
    }
}