panel_git_repos.cpp

Go to the documentation of this file.

/*
 * This program source code file is part of KiCad, a free EDA CAD application.
 *
 * Copyright (C) 2018-2023 KiCad Developers, see AUTHORS.txt for contributors.
 *
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation, either version 3 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "panel_git_repos.h"
 
#include <bitmaps.h>
#include <dialogs/git/dialog_git_repository.h>
#include <kiplatform/secrets.h>
#include <pgm_base.h>
#include <settings/common_settings.h>
#include <widgets/std_bitmap_button.h>
#include <widgets/wx_grid.h>
 
#include <git2.h>
#include <wx/bmpbuttn.h>
#include <wx/button.h>
#include <wx/checkbox.h>
#include <wx/log.h>
 
 
PANEL_GIT_REPOS::PANEL_GIT_REPOS( wxWindow* aParent ) : PANEL_GIT_REPOS_BASE( aParent)
{
 
 m_btnAddRepo->SetBitmap( KiBitmapBundle( BITMAPS::small_plus ) );
 m_btnEditRepo->SetBitmap( KiBitmapBundle( BITMAPS::small_edit ) );
 m_btnDelete->SetBitmap( KiBitmapBundle( BITMAPS::small_trash ) );
 
}
 
PANEL_GIT_REPOS::~PANEL_GIT_REPOS()
{
}
 
 
void PANEL_GIT_REPOS::ResetPanel()
{
 m_grid->ClearGrid();
 m_cbDefault->SetValue( true );
 m_author->SetValue( wxEmptyString );
 m_authorEmail->SetValue( wxEmptyString );
}
 
static std::pair<wxString, wxString> getDefaultAuthorAndEmail()
{
 wxString name;
 wxString email;
 git_config_entry* name_c = nullptr;
 git_config_entry* email_c = nullptr;
 
 git_config* config = nullptr;
 
 if( git_config_open_default( &config ) != 0 )
 {
 printf( "Failed to open default Git config: %s\n", giterr_last()->message );
 return std::make_pair( name, email );
 }
 
 if( git_config_get_entry( &name_c, config, "user.name" ) != 0 )
 {
 printf( "Failed to get user.name from Git config: %s\n", giterr_last()->message );
 }
 if( git_config_get_entry( &email_c, config, "user.email" ) != 0 )
 {
 printf( "Failed to get user.email from Git config: %s\n", giterr_last()->message );
 }
 
 if( name_c )
 name = name_c->value;
 
 if( email_c )
 email = email_c->value;
 
 git_config_entry_free( name_c );
 git_config_entry_free( email_c );
 git_config_free( config );
 
 return std::make_pair( name, email );
}
 
bool PANEL_GIT_REPOS::TransferDataFromWindow()
{
 COMMON_SETTINGS* settings = Pgm().GetCommonSettings();
 std::vector<COMMON_SETTINGS::GIT_REPOSITORY>& repos = settings->m_Git.repositories;
 
 repos.clear();
 
 for( int row = 0; row < m_grid->GetNumberRows(); row++ )
 {
 COMMON_SETTINGS::GIT_REPOSITORY repo;
 
 repo.active = m_grid->GetCellValue( row, COL_ACTIVE ) == "1";
 repo.name = m_grid->GetCellValue( row, COL_NAME );
 repo.path = m_grid->GetCellValue( row, COL_PATH );
 repo.authType = m_grid->GetCellValue( row, COL_AUTH_TYPE );
 repo.username = m_grid->GetCellValue( row, COL_USERNAME );
 
 KIPLATFORM::SECRETS::StoreSecret( repo.path, repo.username,
 m_grid->GetCellValue( row, COL_PASSWORD ) );
 repo.ssh_path = m_grid->GetCellValue( row, COL_SSH_PATH );
 repo.checkValid = m_grid->GetCellValue( row, COL_STATUS ) == "1";
 repos.push_back( repo );
 }
 
 settings->m_Git.useDefaultAuthor = m_cbDefault->GetValue();
 settings->m_Git.authorName = m_author->GetValue();
 settings->m_Git.authorEmail = m_authorEmail->GetValue();
 
 return true;
}
 
static bool testRepositoryConnection( COMMON_SETTINGS::GIT_REPOSITORY& repository)
{
 git_libgit2_init();
 
 git_remote_callbacks callbacks;
 callbacks.version = GIT_REMOTE_CALLBACKS_VERSION;
 
 typedef struct
 {
 COMMON_SETTINGS::GIT_REPOSITORY* repo;
 bool success;
 } callbacksPayload;
 
 callbacksPayload cb_data( { &repository, true } ); // If we don't need authentication, then,
 // we are successful
 callbacks.payload = &cb_data;
 callbacks.credentials =
 [](git_cred** out, const char* url, const char* username, unsigned int allowed_types,
 void* payload) -> int
 {
 
 // If we are asking for credentials, then, we need authentication
 
 callbacksPayload* data = static_cast<callbacksPayload*>(payload);
 
 data->success = false;
 
 if( allowed_types & GIT_CREDTYPE_USERNAME )
 {
 data->success = true;
 }
 else if( data->repo->authType == "ssh" && ( allowed_types & GIT_CREDTYPE_SSH_KEY ) )
 {
 wxString sshKeyPath = data->repo->ssh_path;
 
 // Check if the SSH key exists and is readable
 if( wxFileExists( sshKeyPath ) && wxFile::Access( sshKeyPath, wxFile::read ) )
 data->success = true;
 }
 else if( data->repo->authType == "password" )
 {
 data->success = ( allowed_types & GIT_CREDTYPE_USERPASS_PLAINTEXT );
 }
 
 return 0;
 };
 
 // Create a temporary directory to initialize the Git repository
 wxString tempDirPath = wxFileName::CreateTempFileName(wxT("kigit_temp"));
 
 if( !wxFileName::Mkdir( tempDirPath, wxS_DIR_DEFAULT ) )
 {
 git_libgit2_shutdown();
 wxLogError( "Failed to create temporary directory for Git repository (%s): %s", tempDirPath,
 wxSysErrorMsg() );
 return false;
 }
 
 // Initialize the Git repository
 git_repository* repo = nullptr;
 int result = git_repository_init( &repo, tempDirPath.mb_str( wxConvUTF8 ), 0 );
 
 if (result != 0)
 {
 git_repository_free(repo);
 git_libgit2_shutdown();
 wxRmdir(tempDirPath);
 return false;
 }
 
 git_remote* remote = nullptr;
 result = git_remote_create_anonymous( &remote, repo, tempDirPath.mb_str( wxConvUTF8 ) );
 
 if (result != 0)
 {
 git_remote_free(remote);
 git_repository_free(repo);
 git_libgit2_shutdown();
 wxRmdir(tempDirPath);
 return false;
 }
 
 // We don't really care about the result of this call, the authentication callback
 // will set the return values we need
 git_remote_connect(remote, GIT_DIRECTION_FETCH, &callbacks, nullptr, nullptr);
 
 git_remote_disconnect(remote);
 git_remote_free(remote);
 git_repository_free(repo);
 
 git_libgit2_shutdown();
 
 // Clean up the temporary directory
 wxRmdir(tempDirPath);
 
 return cb_data.success;
}
 
bool PANEL_GIT_REPOS::TransferDataToWindow()
{
 COMMON_SETTINGS* settings = Pgm().GetCommonSettings();
 
 m_grid->ClearGrid();
 
 for( COMMON_SETTINGS::GIT_REPOSITORY& repo : settings->m_Git.repositories )
 {
 if( repo.name.IsEmpty() || repo.path.IsEmpty() )
 continue;
 
 int row = m_grid->GetNumberRows();
 m_grid->AppendRows( 1 );
 
 m_grid->SetCellRenderer( row, COL_ACTIVE, new wxGridCellBoolRenderer() );
 m_grid->SetCellEditor( row, COL_ACTIVE, new wxGridCellBoolEditor() );
 m_grid->SetCellValue( row, COL_ACTIVE, repo.active ? "1" : "0" );
 
 m_grid->SetCellValue( row, COL_NAME, repo.name );
 m_grid->SetCellValue( row, COL_PATH, repo.path );
 m_grid->SetCellValue( row, COL_AUTH_TYPE, repo.authType );
 m_grid->SetCellValue( row, COL_USERNAME, repo.username );
 
 wxString password;
 KIPLATFORM::SECRETS::GetSecret( repo.path, repo.username, password );
 m_grid->SetCellValue( row, COL_PASSWORD, password );
 m_grid->SetCellValue( row, COL_SSH_PATH, repo.ssh_path );
 
 if( repo.active )
 m_grid->SetCellValue( row, 3, testRepositoryConnection( repo ) ? "C" : "NC" );
 
 }
 
 m_cbDefault->SetValue( settings->m_Git.useDefaultAuthor );
 
 if( settings->m_Git.useDefaultAuthor )
 {
 std::pair<wxString, wxString> defaultAuthor = getDefaultAuthorAndEmail();
 m_author->SetValue( defaultAuthor.first );
 m_authorEmail->SetValue( defaultAuthor.second );
 m_author->Disable();
 m_authorEmail->Disable();
 }
 else
 {
 m_author->SetValue( settings->m_Git.authorName );
 m_authorEmail->SetValue( settings->m_Git.authorEmail );
 }
 
 return true;
}
 
void PANEL_GIT_REPOS::onDefaultClick( wxCommandEvent& event )
{
 m_author->Enable( !m_cbDefault->GetValue() );
 m_authorEmail->Enable( !m_cbDefault->GetValue() );
 m_authorLabel->Enable( !m_cbDefault->GetValue() );
 m_authorEmailLabel->Enable( !m_cbDefault->GetValue() );
}
 
 
void PANEL_GIT_REPOS::onGridDClick( wxGridEvent& event )
{
 if( m_grid->GetNumberRows() <= 0 )
 {
 wxCommandEvent evt;
 onAddClick( evt );
 return;
 }
 
 int row = event.GetRow();
 
 if( row < 0 || row >= m_grid->GetNumberRows() )
 return;
 
 DIALOG_GIT_REPOSITORY dialog( this, nullptr );
 
 dialog.SetRepoName( m_grid->GetCellValue( row, COL_NAME ) );
 dialog.SetRepoURL( m_grid->GetCellValue( row, COL_PATH ) );
 dialog.SetUsername( m_grid->GetCellValue( row, COL_USERNAME ) );
 dialog.SetRepoSSHPath( m_grid->GetCellValue( row, COL_SSH_PATH ) );
 dialog.SetPassword( m_grid->GetCellValue( row, COL_PASSWORD ) );
 
 wxString type = m_grid->GetCellValue( row, COL_AUTH_TYPE );
 
 if( type == "password" )
 dialog.SetRepoType( KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_HTTPS );
 else if( type == "ssh" )
 dialog.SetRepoType( KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH );
 else
 dialog.SetRepoType( KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_LOCAL);
 
 if( dialog.ShowModal() == wxID_OK )
 {
 m_grid->SetCellValue( row, COL_NAME, dialog.GetRepoName() );
 m_grid->SetCellValue( row, COL_PATH, dialog.GetRepoURL() );
 m_grid->SetCellValue( row, COL_USERNAME, dialog.GetUsername() );
 m_grid->SetCellValue( row, COL_SSH_PATH, dialog.GetRepoSSHPath() );
 m_grid->SetCellValue( row, COL_PASSWORD, dialog.GetPassword() );
 
 if( dialog.GetRepoType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_HTTPS )
 {
 m_grid->SetCellValue( row, COL_AUTH_TYPE, "password" );
 }
 else if( dialog.GetRepoType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH )
 {
 m_grid->SetCellValue( row, COL_AUTH_TYPE, "ssh" );
 }
 else
 {
 m_grid->SetCellValue( row, COL_AUTH_TYPE, "none" );
 }
 }
 
}
 
 
void PANEL_GIT_REPOS::onAddClick( wxCommandEvent& event )
{
 
 DIALOG_GIT_REPOSITORY dialog( m_parent, nullptr );
 
 if( dialog.ShowModal() == wxID_OK )
 {
 int row = m_grid->GetNumberRows();
 m_grid->AppendRows( 1 );
 
 m_grid->SetCellValue( row, COL_NAME, dialog.GetRepoName() );
 m_grid->SetCellValue( row, COL_PATH, dialog.GetRepoURL() );
 m_grid->SetCellValue( row, COL_USERNAME, dialog.GetUsername() );
 m_grid->SetCellValue( row, COL_SSH_PATH, dialog.GetRepoSSHPath() );
 m_grid->SetCellValue( row, COL_PASSWORD, dialog.GetPassword() );
 
 if( dialog.GetRepoType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_HTTPS )
 {
 m_grid->SetCellValue( row, COL_AUTH_TYPE, "password" );
 }
 else if( dialog.GetRepoType() == KIGIT_COMMON::GIT_CONN_TYPE::GIT_CONN_SSH )
 {
 m_grid->SetCellValue( row, COL_AUTH_TYPE, "ssh" );
 }
 else
 {
 m_grid->SetCellValue( row, COL_AUTH_TYPE, "none" );
 }
 
 m_grid->MakeCellVisible( row, 0 );
 }
}
 
 
void PANEL_GIT_REPOS::onEditClick( wxCommandEvent& event )
{
 wxGridEvent evt( m_grid->GetId(), wxEVT_GRID_CELL_LEFT_DCLICK, m_grid,
 m_grid->GetGridCursorRow(), m_grid->GetGridCursorCol() );
 onGridDClick( evt );
}
 
 
void PANEL_GIT_REPOS::onDeleteClick( wxCommandEvent& event )
{
 if( !m_grid->CommitPendingChanges() || m_grid->GetNumberRows() <= 0 )
 return;
 
 int curRow = m_grid->GetGridCursorRow();
 
 m_grid->DeleteRows( curRow );
 
 curRow = std::max( 0, curRow - 1 );
 m_grid->MakeCellVisible( curRow, m_grid->GetGridCursorCol() );
 m_grid->SetGridCursor( curRow, m_grid->GetGridCursorCol() );
}