Add docsting for pass plugin

how to export the specficic files needed for UTPass to work properly.

.astylerc

@@ -5,8 +5,7 @@ suffix=none
 --align-reference=name
 --convert-tabs
 --attach-namespaces
---max-code-length=100
+--max-code-length=120
---max-instatement-indent=120
 --pad-header
 --pad-oper
 --lineend=linux

.github/FUNDING.yml

@@ -0,0 +1,2 @@
+ko_fi: qrouland # Replace with a single Ko-fi username
+

.gitignore

@@ -1,5 +1,6 @@
 # Builds dirs 
 build*
+.cache 
 
 # IDE & Devs tools
 .clickable
@@ -10,13 +11,7 @@ build*
 *.kdev4
 *swp
 scripts
+CMakeLists.txt.*
 
-# Third parties ouput dir
+# venv
-libs/third/local
+venv
-
-
-# desktop
-desktop
-
-# Test (Not Ready yet !) 
-tests

.gitmodules

@@ -1,30 +0,0 @@
-[submodule "third/gpgme"]
-	path = libs/gpg/gpgme
-	url = https://github.com/gpg/gpgme
-[submodule "third/libassuan"]
-	path = libs/gpg/libassuan
-	url = https://github.com/gpg/libassuan
-[submodule "third/libgpg-error"]
-	path = libs/gpg/libgpg-error
-	url = https://github.com/gpg/libgpg-error
-[submodule "third/gnupg"]
-	path = libs/gpg/gnupg
-	url = https://github.com/gpg/gnupg
-[submodule "libs/utils/quazip"]
-	path = libs/quazip
-	url = https://github.com/stachenov/quazip
-[submodule "libs/gpg/gpgme"]
-	path = libs/gpg/gpgme
-	url = https://github.com/gpg/gpgme
-[submodule "libs/gpg/libassuan"]
-	path = libs/gpg/libassuan
-	url = https://github.com/gpg/libassuan
-[submodule "libs/gpg/libgpg-error"]
-	path = libs/gpg/libgpg-error
-	url = https://github.com/gpg/libgpg-error
-[submodule "libs/gpg/gnupg"]
-	path = libs/gpg/gnupg
-	url = https://github.com/gpg/gnupg
-[submodule "libs/quazip"]
-	path = libs/quazip
-	url = https://github.com/stachenov/quazip

CMakeLists.txt

@@ -3,6 +3,10 @@ cmake_minimum_required(VERSION 3.5.1)
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 
+if(NOT CMAKE_BUILD_TYPE)
+    set(CMAKE_BUILD_TYPE "Release")
+endif()
+
 execute_process(
         COMMAND dpkg-architecture -qDEB_HOST_ARCH
         OUTPUT_VARIABLE CLICK_ARCH
@@ -28,11 +32,22 @@ set(PROJECT_NAME "UTPass")
 set(FULL_PROJECT_NAME "utpass.qrouland")
 set(CMAKE_INSTALL_PREFIX /)
 set(DATA_DIR /)
-set(BIN_DIR ${DATA_DIR}lib/bin)
+
 set(DESKTOP_FILE_NAME ${PROJECT_NAME}.desktop)
 
+if(NOT TESTS_PATH)
+    set(TESTS_PATH "./tests")
+endif()
+
+configure_file(main.in.cpp main.cpp)
+
 add_executable(${PROJECT_NAME} main.cpp)
-qt5_use_modules(${PROJECT_NAME} Gui Qml Quick)
+qt5_use_modules(${PROJECT_NAME} Gui Qml Quick QuickTest)
+
+if(TESTS_RUNNER)
+    qt5_use_modules(${PROJECT_NAME} QuickTest)
+endif()
+
 
 install(TARGETS ${PROJECT_NAME} RUNTIME DESTINATION ${CMAKE_INSTALL_PREFIX})
 
@@ -41,20 +56,13 @@ configure_file(${CMAKE_CURRENT_BINARY_DIR}/manifest.json ${CMAKE_CURRENT_BINARY_
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/manifest.json DESTINATION ${CMAKE_INSTALL_PREFIX})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/manifest_.json DESTINATION ${DATA_DIR})
 
-#install(DIRECTORY desktop DESTINATION ${DATA_DIR})
 
 install(FILES ${PROJECT_NAME}.apparmor DESTINATION ${DATA_DIR})
 install(FILES ${PROJECT_NAME}.contenthub DESTINATION ${DATA_DIR})
 install(FILES LICENSE DESTINATION ${DATA_DIR})
 install(DIRECTORY qml DESTINATION ${DATA_DIR})
 install(DIRECTORY assets DESTINATION ${DATA_DIR})
-file(GLOB_RECURSE BIN_FILES
+
-        "build/${ARCH_TRIPLET}/gpg/local/bin/*")
-install(
-        FILES ${BIN_FILES}
-        PERMISSIONS OWNER_EXECUTE OWNER_WRITE OWNER_READ GROUP_READ GROUP_EXECUTE WORLD_READ WORLD_EXECUTE
-        DESTINATION ${BIN_DIR}
-)
 
 # Translations
 file(GLOB_RECURSE I18N_SRC_FILES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}/po qml/*.qml qml/*.js)
@@ -79,6 +87,9 @@ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${DESKTOP_FILE_NAME} DESTINATION ${DAT
 
 add_subdirectory(po)
 add_subdirectory(plugins)
+if(TESTS_RUNNER)
+    add_subdirectory(tests/plugins)
+endif()
+
 
 add_custom_target(${PROJECT_NAME}_FILES ALL SOURCES ${PROJECT_SRC_FILES})
-

README.md

@@ -8,35 +8,36 @@ UTPass is avalaible on the [OpenStore](open-store.io)
 
 [![OpenStore](https://open-store.io/badges/en_US.png)](https://open-store.io/app/utpass.qrouland)
 
-## Build & Tests
-
-See [Build & Tests wiki page](https://taiga.rdrive.ovh/project/utpass/wiki/build-tests)
-
-## Contributing & Issues
-
-See [Contributing wiki page](https://taiga.rdrive.ovh/project/utpass/wiki/contributing)
 
 ## Features
 
 The goal is to be closest possible of the features offer by [ZX2C4’s pass command line application](https://www.passwordstore.org/). 
 See [Features wiki page](https://taiga.rdrive.ovh/project/utpass/wiki/contributing) for details.
 
-## License
+## Export/Import
 
-    Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+Assuming that there are already passwords in another device using [ZX2C4’s pass command line application](https://www.passwordstore.org/) and, therefore, that [gpg keys](https://gnupg.org/) have been previously generated for encryption purposes, these may be helpful commands:
 
-    This program is free software: you can redistribute it and/or modify
+Export gpg private keys in order to decrypt passwords:
-    it under the terms of the GNU General Public License as published by
+```
-    the Free Software Foundation, either version 3 of the License, or
+gpg --output keys.gpg --export-secret-keys
-    (at your option) any later version.
+```
 
-    This program is distributed in the hope that it will be useful,
+Export passwords, assuming they reside in *.password-store* folder:
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
+```
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+zip passwords.zip -r .password-store/
-    GNU General Public License for more details.
+```
 
-    You should have received a copy of the GNU General Public License
+Both files have the correct format for UTPass to import them and work as intended. It is highly recommended to remove them after imported to **UTPass**.
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+## Build & Tests
+
+See [Build & Tests wiki page](https://github.com/QRouland/UTPass/wiki/Build-&-Tests)
+
+## Contributing & Issues
+
+See [Contributing wiki page](https://github.com/QRouland/UTPass/wiki/Contributing)
 
 
 ## Useful Links
@@ -45,4 +46,23 @@ Some useful links related to UTPass development :
 * [Ubports](https://ubports.com/) : Ubuntu Touch Community
 * [ZX2C4’s pass command line application](https://www.passwordstore.org/) : the standard unix password manager.
 * [Clickable](https://github.com/bhdouglass/clickable) : Compile, build, and deploy Ubuntu Touch click packages
+* [GnuPG](https://gnupg.org/): The GNU Privacy Guard
 * [Gpgme](https://www.gnupg.org/software/gpgme/index.html) : GnuPG Made Easy (GPGME) is a library designed to make access to GnuPG easier for applications
+
+
+## License
+
+Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+
+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/>.

UTPass.apparmor

@@ -1,6 +1,7 @@
 {
     "policy_groups": [
-        "content_exchange"
+        "content_exchange",
+        "networking"
     ],
-    "policy_version": 16.04
+    "policy_version": 20.04
 }

UTPass.desktop.in

@@ -4,4 +4,4 @@ Exec=UTPass
 Icon=assets/logo.svg
 Terminal=false
 Type=Application
-X-Ubuntu-Touch=true
+X-Lomiri-Touch=true

clickable.json

@@ -1,22 +0,0 @@
-{
-  "template": "cmake",
-  "kill": "UTPass",
-  "scripts": {
-    "style": "echo 'Astyle :' && astyle --options=.astylerc main.cpp && astyle --options=.astylerc --recursive 'plugins/*.cpp,*.h' && echo 'QmlFmt :' && qmlfmt -l tests && qmlfmt -w tests && qmlfmt -l qml && qmlfmt -w qml"
-  },
-  "libraries": {
-     "gpg": {
-        "template": "cmake",
-        "make_jobs": 4,
-        "dependencies_build": [
-            "texinfo",
-            "gpgsm",
-            "bison"
-        ]
-     },
-      "quazip": {
-        "template": "cmake",
-        "make_jobs": 4
-     }
-   }
-}

clickable.yaml

@@ -0,0 +1,34 @@
+clickable_minimum_required: 8
+builder: cmake
+kill: UTPass
+
+scripts:
+  style: >-
+    echo 'Running Astyle :' && astyle --options=.astylerc --recursive '*.cpp,*.h' --exclude=build && echo 'Running QmlFormat' && find . -name "*.qml" -exec qmlformat -i {} \; && echo 'Success'
+
+
+
+
+dependencies_target:
+- libgpgmepp-dev
+- libgpgme-dev
+- libgit2-dev
+- libquazip5-dev
+- gpg
+
+install_lib:
+- "libgpg-error.so.0.28.0"
+- "libassuan.so*"
+- "libgpgme.so*"
+- "libgpgmepp.so*"
+- "libqgpgme.so*"
+- "libgit2.so*"
+- "libquazip5.so*"
+- "libmbedtls.so*"
+- "libmbedx509.so*"
+- "libmbedcrypto.so*"
+- "libhttp_parser.so*"
+- "libssh2.so*"
+
+install_bin:
+- "gpg"

libs/gpg/CMakeLists.txt

@@ -1,68 +0,0 @@
-cmake_minimum_required(VERSION 3.5.1)
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
-include(${CMAKE_ROOT}/Modules/ExternalProject.cmake)
-
-execute_process(
-        COMMAND dpkg-architecture -qDEB_HOST_MULTIARCH
-        OUTPUT_VARIABLE ARCH_TRIPLET
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-)
-
-execute_process (
-    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/clean.sh ${ARCH_TRIPLET}
-)
-
-set(EXTERNAL_LIBS "${CMAKE_CURRENT_BINARY_DIR}/local/")
-set(THIRD_PATH "${CMAKE_CURRENT_SOURCE_DIR}")
-set(LIBGPGERROR_PATH "${THIRD_PATH}/libgpg-error")
-set(LIBASSUAN_PATH "${THIRD_PATH}/libassuan")
-set(LIBGPGME_PATH "${THIRD_PATH}/gpgme")
-set(GNUPG_PATH "${THIRD_PATH}/gnupg")
-
-ExternalProject_Add(
-        LibGpgError
-        INSTALL_DIR ${EXTERNAL_LIBS}
-        DOWNLOAD_COMMAND ""
-        SOURCE_DIR ${LIBGPGERROR_PATH}
-        CONFIGURE_COMMAND <SOURCE_DIR>/autogen.sh && <SOURCE_DIR>/configure --prefix=${EXTERNAL_LIBS} --enable-static=yes --enable-shared=no --with-pic=yes --enable-maintainer-mode --host ${ARCH_TRIPLET} --disable-doc --disable-dependency-tracking
-        BUILD_IN_SOURCE 1
-        BUILD_COMMAND make
-        INSTALL_COMMAND make install
-)
-
-ExternalProject_Add(
-        LibGpgAssuan
-        DEPENDS LibGpgError
-        INSTALL_DIR ${EXTERNAL_LIBS}
-        DOWNLOAD_COMMAND ""
-        SOURCE_DIR ${LIBASSUAN_PATH}
-        CONFIGURE_COMMAND <SOURCE_DIR>/autogen.sh && <SOURCE_DIR>/configure --prefix=${EXTERNAL_LIBS} --enable-static=yes --enable-shared=no --with-pic=yes --enable-maintainer-mode --with-libgpg-error-prefix=${EXTERNAL_LIBS} --host ${ARCH_TRIPLET} --disable-doc --disable-dependency-tracking
-        BUILD_IN_SOURCE 1
-        BUILD_COMMAND make
-        INSTALL_COMMAND make install
-)
-
-ExternalProject_Add(
-        LibGpgme
-        DEPENDS LibGpgError LibGpgAssuan
-        INSTALL_DIR ${EXTERNAL_LIBS}
-        DOWNLOAD_COMMAND ""
-        SOURCE_DIR ${LIBGPGME_PATH}
-        CONFIGURE_COMMAND <SOURCE_DIR>/autogen.sh && <SOURCE_DIR>/configure  --enable-languages=cpp,qt  --enable-static=yes --enable-shared=no --with-pic=yes --prefix=${EXTERNAL_LIBS} --enable-maintainer-mode --with-libgpg-error-prefix=${EXTERNAL_LIBS} --with-libassuan-prefix=${EXTERNAL_LIBS} --host ${ARCH_TRIPLET} --disable-doc --disable-largefile --disable-dependency-tracking
-        BUILD_IN_SOURCE 1
-        BUILD_COMMAND make
-        INSTALL_COMMAND make install
-)
-
-
-ExternalProject_Add(
-        Gnupg
-        DEPENDS LibGpgError LibGpgAssuan
-        INSTALL_DIR ${EXTERNAL_LIBS}
-        DOWNLOAD_COMMAND ""
-        SOURCE_DIR ${GNUPG_PATH}
-        CONFIGURE_COMMAND <SOURCE_DIR>/autogen.sh && <SOURCE_DIR>/configure  --prefix=${EXTERNAL_LIBS} --with-libgpg-error-prefix=${EXTERNAL_LIBS} --with-libassuan-prefix=${EXTERNAL_LIBS} --enable-maintainer-mode --with-libassuan-prefix=${EXTERNAL_LIBS} --host ${ARCH_TRIPLET} --disable-doc --disable-dependency-tracking
-        BUILD_IN_SOURCE 1 
-        BUILD_COMMAND make
-        INSTALL_COMMAND make install
-)

libs/gpg/clean.sh

@@ -1,14 +0,0 @@
-#!/bin/bash
-SCRIPTPATH="$( cd "$(dirname "$0")" ; pwd -P )"
-
-if [ ! -z "$1" ] && [ -d  $SCRIPTPATH/../../build/$1/gpg ]; then
-    rm -rf $SCRIPTPATH/../../build/$1/gpg
-fi
-
-git submodule update --init --recursive
-
-for LIB in $SCRIPTPATH/*/
-do
-    echo $LIB
-    cd $LIB && git clean -xdf && git reset --hard HEAD
-done

main.in.cpp

@@ -6,6 +6,10 @@
 #include <QtQml>
 
 
+#ifdef TEST_RUNNER
+#include <QtQuickTest/quicktest.h>
+#endif
+
 int main(int argc, char *argv[])
 {
     qDebug() << "Starting app from main.cpp";
@@ -13,6 +17,7 @@ int main(int argc, char *argv[])
 
     QGuiApplication::setApplicationName("utpass.qrouland");
 
+#ifndef TEST_RUNNER
     auto *view = new QQuickView();
     view->setSource(QUrl(QStringLiteral("qml/Main.qml")));
     view->setResizeMode(QQuickView::SizeRootObjectToView);
@@ -23,4 +28,7 @@ int main(int argc, char *argv[])
         Q_ARG(QVariant, QVariant::fromValue(mainView))
     );
     return QGuiApplication::exec();
+#else
+    return quick_test_main(argc, argv, "@TESTS_PATH@", "@TESTS_PATH@");
+#endif
 }

manifest.json.in

@@ -10,7 +10,7 @@
             "content-hub": "UTPass.contenthub"
         }
     },
-    "version": "0.0.2",
+    "version": "0.0.3-dev",
     "maintainer": "Quentin Rouland <quentin@qrouland.com>",
-    "framework" : "ubuntu-sdk-16.04"
+    "framework" : "ubuntu-sdk-20.04"
 }

plugins/CMakeLists.txt

@@ -1,2 +1,3 @@
+add_subdirectory(Git)
 add_subdirectory(Pass)
 add_subdirectory(Utils)

plugins/Git/CMakeLists.txt

@@ -0,0 +1,37 @@
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
+set(PLUGIN "Git")
+
+set(
+        SRC
+        plugin.cpp
+        libgit.cpp
+        git.cpp
+        utils.h
+)
+
+set(CMAKE_AUTOMOC ON)
+
+execute_process(
+        COMMAND dpkg-architecture -qDEB_HOST_MULTIARCH
+        OUTPUT_VARIABLE ARCH_TRIPLET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+if(ARCH_TRIPLET STREQUAL "")
+    set(ARCH_TRIPLET x86_64-linux-gnu)
+endif()
+
+add_library(${PLUGIN} MODULE ${SRC})
+set_target_properties(${PLUGIN} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PLUGIN})
+qt5_use_modules(${PLUGIN} Qml Quick DBus)
+
+
+add_library(libgit2 SHARED IMPORTED)
+set_property(TARGET libgit2 PROPERTY IMPORTED_LOCATION "/usr/lib/${ARCH_TRIPLET}/libgit2.so")
+
+target_link_libraries(${PLUGIN} libgit2)
+
+
+set(QT_IMPORTS_DIR "/lib/${ARCH_TRIPLET}")
+install(TARGETS ${PLUGIN} DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN}/)
+install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN}/)

plugins/Git/git.cpp

@@ -0,0 +1,77 @@
+#include <QUrl>
+#include <QtCore/QDir>
+#include <QDebug>
+#include <QStandardPaths>
+
+
+#include "git.h"
+#include "libgit.h"
+#include "utils.h"
+
+
+QDir Git::cloneSetup()
+{
+    QDir tmp_dir(QStandardPaths::writableLocation( QStandardPaths::CacheLocation).append("/clone"));
+
+    tmp_dir.removeRecursively();
+    qDebug() << "Temp dir path is " << tmp_dir.absolutePath();
+
+    return tmp_dir;
+}
+
+
+bool Git::cloneTearDown(QDir tmp_dir)
+{
+    return tmp_dir.removeRecursively();
+}
+
+bool Git::moveToDestination(QString path, QDir tmp_dir)
+{
+    qDebug() << "Removing password_store " << path;
+    QDir destination_dir(path);
+    destination_dir.removeRecursively();
+
+    qDebug() << "Moving cloned content to destination dir";
+    QDir dir;
+    qDebug() <<  tmp_dir.absolutePath() << " to " << destination_dir.absolutePath();
+    return dir.rename(tmp_dir.absolutePath(), destination_dir.absolutePath()); // TODO Better error handling
+}
+
+bool Git::clone(QString url, QString path, mode_type mode) //, GitPlugin::RepoType type, QString pass)
+{
+    auto v =  overload {
+        [](const Unset & x)  { return "Unset"; },
+        [](const HTTP & x)   { return "HTTP"; },
+        [](const HTTPAuth & x)   { return "HTTPAuth"; },
+        [](const SSHAuth & x)   { return "SSHAuth"; },
+        [](const SSHKey & x)   { return "SSHKey"; },
+    };
+    qInfo() << "Cloning " << url << " to destination " << path << " using " << std::visit(v, mode);
+
+    LibGit::instance()->setMode(mode);
+    auto tmp_dir = this->cloneSetup();
+
+    qDebug() << "Cloning " << url << " to tmp dir " << tmp_dir.absolutePath();
+    auto ret = LibGit::instance()->clone(url, tmp_dir.absolutePath()); // TODO Better error handling
+
+    if (ret) {
+        this->moveToDestination(path, tmp_dir);
+    }
+
+    this->cloneTearDown(tmp_dir);
+    LibGit::instance()->setMode(Unset());
+
+    return ret ;
+}
+
+bool Git::cloneHttp(QString url, QString path)
+{
+    HTTP mode = {};
+    return this->clone(url, path, mode);
+}
+
+bool Git::cloneHttpPass(QString url, QString path, QString pass)
+{
+    HTTPAuth mode = { pass };
+    return this->clone(url, path, mode);
+}

plugins/Git/git.h

@@ -0,0 +1,35 @@
+#ifndef GIT_H
+#define GIT_H
+
+#include <QUrl>
+#include <QObject>
+#include <QtCore/QDir>
+
+#include "libgit.h"
+
+/**
+ * @brief The Git class is class that provide Git functionnly to clone and update a repo.
+ */
+class Git : public QObject
+{
+    Q_OBJECT
+
+private:
+    QDir cloneSetup();
+    bool moveToDestination(QString path, QDir tmp_dir);
+    bool cloneTearDown(QDir tmp_dir);
+    bool clone(QString url, QString path, mode_type mode);
+
+
+public:
+    Git() = default;
+    ~Git() override = default;
+
+    Q_INVOKABLE bool cloneHttp(QString url, QString path);
+    Q_INVOKABLE bool cloneHttpPass(QString url, QString path, QString pass);
+    // Q_INVOKABLE bool clone_ssh_pass(QString url, QString path, QString pass);
+    // Q_INVOKABLE bool clone_ssh_key(QString url, QString path, QString pub_key, QString priv_key, QString passphrase);
+    // Q_INVOKABLE bool update(QUrl url, QString path);
+};
+
+#endif

plugins/Git/libgit.cpp

@@ -0,0 +1,89 @@
+#include <QUrl>
+#include <QDebug>
+
+#include <type_traits>
+extern "C" {
+#include <git2.h>
+}
+
+#include "libgit.h"
+#include "utils.h"
+
+
+
+LibGit::LibGit()
+{
+    git_libgit2_init();
+}
+
+LibGit::~LibGit()
+{
+    git_libgit2_shutdown();
+}
+
+void LibGit::setMode(mode_type type)
+{
+    this->mode = type;
+}
+
+int LibGit::credentialsCB(git_cred **out, const char *url, const char *username_from_url,
+                          unsigned int allowed_types, void *payload)
+{
+    // TODO : More precise Error Handling for UI
+    auto instance = LibGit::instance();
+    auto v =  overload {
+        [](const Unset & x)
+        {
+            qDebug() << "credentials_cb : Unset ";
+            qWarning() << "credentials_cb : callback should never be call for Unset ";
+            return (int) GIT_EUSER;
+        },
+        [](const HTTP & x)
+        {
+            qDebug() << "credentials_cb : HTTP ";
+            qWarning() << "credentials_cb : callback should never be call for HTTP ";
+            return (int) GIT_EUSER;
+        },
+        [&out, &username_from_url](const HTTPAuth & x)
+        {
+            qDebug() << "credentials_cb : HTTPAuth ";
+            if (!username_from_url) {
+                qWarning() << "credentials_cb : no username provided ";
+                return (int) GIT_EUSER;
+            }
+            return git_cred_userpass_plaintext_new(out, username_from_url, x.pass.toLocal8Bit().constData());
+        },
+        [&](const SSHAuth & x)
+        {
+            qWarning() << "credentials_cb : SSHAuth to be implemented ";
+            return (int) GIT_EUSER;
+        }, // TODO
+        [&](const SSHKey & x)
+        {
+            qWarning() << "credentials_cb : SSHKey to be implemented ";
+            return (int) GIT_EUSER;
+        }  // TODO
+    };
+    return std::visit(v, instance->mode);
+}
+
+
+bool LibGit::clone(QString url, QString path)
+{
+    git_repository *repo = NULL;
+    git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
+
+    opts.fetch_opts.callbacks.credentials = *credentialsCB;
+
+    int ret = git_clone(&repo, url.toLocal8Bit().data(), path.toLocal8Bit().data(), &opts);
+    if (ret != 0) {
+        qDebug() << git_error_last()->message;
+    }
+    if (repo) {
+        git_repository_free(repo);
+    }
+    return ret == 0; // TODO Clean error handling to return specifics errors for the ui
+
+    return ret;
+}
+

plugins/Git/libgit.h

@@ -0,0 +1,46 @@
+#ifndef LIBGIT_H
+#define LIBGIT_H
+
+#include <QObject>
+#include <QUrl>
+#include <git2/clone.h>
+extern "C" {
+#include <git2/transport.h>
+}
+#include <memory>
+#include <variant>
+
+struct Unset { };
+struct HTTP { };
+struct HTTPAuth {
+    QString pass;
+};
+struct SSHAuth { };
+struct SSHKey { };
+typedef std::variant<Unset, HTTP, HTTPAuth, SSHAuth, SSHKey> mode_type;
+
+class LibGit
+{
+private:
+    LibGit();
+
+    mode_type mode;
+
+    static int credentialsCB(git_cred **out, const char *url, const char *username_from_url,
+                             unsigned int allowed_types, void *payload);
+
+public:
+    ~LibGit();
+    static std::shared_ptr<LibGit> instance()
+    {
+        static std::shared_ptr<LibGit> s{new LibGit};
+        return s;
+    }
+    LibGit(LibGit const &) = delete;
+    void operator=(LibGit const &) = delete;
+
+    bool clone(QString url, QString path);
+    void setMode(mode_type type);
+};
+
+#endif

plugins/Git/plugin.cpp

@@ -0,0 +1,13 @@
+#include <QtQml>
+#include <cstring>
+
+#include "plugin.h"
+#include "git.h"
+
+
+void GitPlugin::registerTypes(const char *uri)
+{
+    //@uri Git
+    qmlRegisterSingletonType<Git>(uri, 1, 0, "Git", [](QQmlEngine *, QJSEngine *) -> QObject * { return new Git; });
+
+}

plugins/Git/plugin.h

@@ -0,0 +1,16 @@
+#ifndef GITPLUGIN_H
+#define GITPLUGIN_H
+
+#include <QQmlExtensionPlugin>
+
+class GitPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID
+                      "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    void registerTypes(const char *uri) override;
+};
+
+#endif

plugins/Git/qmldir

@@ -0,0 +1,2 @@
+module Git
+plugin Git

plugins/Git/utils.h

@@ -0,0 +1,11 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+template<class... Ts>
+struct overload : Ts... {
+    using Ts::operator()...;
+};
+template<class... Ts>
+overload(Ts...) -> overload<Ts...>;
+
+#endif // UTILS_H

plugins/Pass/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
 set(PLUGIN "Pass")
 
 set(
@@ -26,29 +26,26 @@ add_library(${PLUGIN} MODULE ${SRC})
 set_target_properties(${PLUGIN} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PLUGIN})
 qt5_use_modules(${PLUGIN} Qml Quick DBus)
 
-set(EXTERNAL_LIBS "${CMAKE_SOURCE_DIR}/build/${ARCH_TRIPLET}/gpg/local/")
 
-INCLUDE_DIRECTORIES(${EXTERNAL_LIBS}/include)
+add_library(gpgerror SHARED IMPORTED)
+set_property(TARGET gpgerror PROPERTY IMPORTED_LOCATION "/usr/lib/${ARCH_TRIPLET}/libgpg-error.so.0.28.0")
 
-add_library(GpgError STATIC IMPORTED)
+add_library(libassuan SHARED IMPORTED)
-set_property(TARGET GpgError PROPERTY IMPORTED_LOCATION "${EXTERNAL_LIBS}/lib/libgpg-error.a")
+set_property(TARGET libassuan PROPERTY IMPORTED_LOCATION "/usr/lib/${ARCH_TRIPLET}/libassuan.so")
 
-add_library(GpgAssuan STATIC IMPORTED)
+add_library(libgpgme SHARED IMPORTED)
-set_property(TARGET GpgAssuan PROPERTY IMPORTED_LOCATION "${EXTERNAL_LIBS}/lib/libassuan.a")
+set_property(TARGET libgpgme PROPERTY IMPORTED_LOCATION "/usr/lib/${ARCH_TRIPLET}/libgpgme.so")
 
-add_library(Gpgme STATIC IMPORTED)
+add_library(libgpgmepp SHARED IMPORTED)
-set_property(TARGET Gpgme PROPERTY IMPORTED_LOCATION "${EXTERNAL_LIBS}/lib/libgpgme.a")
+set_property(TARGET libgpgmepp PROPERTY IMPORTED_LOCATION "/usr/lib/${ARCH_TRIPLET}/libgpgmepp.so")
 
-add_library(Gpgmepp STATIC IMPORTED)
+add_library(libqgpgme SHARED IMPORTED)
-set_property(TARGET Gpgmepp PROPERTY IMPORTED_LOCATION "${EXTERNAL_LIBS}/lib/libgpgmepp.a")
+set_property(TARGET libqgpgme PROPERTY IMPORTED_LOCATION "/usr/lib/${ARCH_TRIPLET}/libqgpgme.so")
 
-add_library(QGpgme STATIC IMPORTED)
-set_property(TARGET QGpgme PROPERTY IMPORTED_LOCATION "${EXTERNAL_LIBS}/lib/libqgpgme.a")
 
-target_link_libraries(${PLUGIN} QGpgme Gpgmepp Gpgme GpgAssuan GpgError)
+target_link_libraries(${PLUGIN} gpgerror libassuan libgpgme libgpgmepp libqgpgme)
 
 
 set(QT_IMPORTS_DIR "/lib/${ARCH_TRIPLET}")
-
 install(TARGETS ${PLUGIN} DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN}/)
 install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN}/)

plugins/Pass/gpg.cpp

@@ -3,7 +3,7 @@
 #include <QFile>
 #include <QDir>
 #include <QtCore/QStandardPaths>
-
+#include <QProcess>
 
 #include <gpgme.h>
 #include <gpgme++/data.h>
@@ -23,25 +23,25 @@
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/changeownertrustjob.h>
 
+
 #include "gpg.h"
-#include "pass.h"
+#include "passkeymodel.h"
 #include "passphraseprovider.h"
 
 
 
 
+
 using namespace GpgME;
 using namespace QGpgME;
 
-Gpg::Gpg()
+Gpg::Gpg(QObject* windows)
 {
-    m_window = nullptr;
+    this->m_passphrase_provider = new UTPassphraseProvider(windows);
-
-    initializeLibrary();
 
     Gpg::initGpgConfig();
 
-    auto  error = checkEngine(OpenPGP);
+    auto error = checkEngine(OpenPGP);
     if (error) {
         qDebug() << "Code Error : " << error.code();
         qDebug() << "Error str : " << error.asString();
@@ -53,6 +53,11 @@ Gpg::Gpg()
     qDebug() << "GNUPG Home is :" << engineInfo(OpenPGP).homeDirectory();
 }
 
+Gpg::~Gpg()
+{
+    delete this->m_passphrase_provider;
+}
+
 
 QString Gpg::initGpgHome()
 {
@@ -66,15 +71,33 @@ QString Gpg::initGpgHome()
 }
 
 
+QString Gpg::findCommandPath(const QString &command)
+{
+    // Retrieve the PATH environment variable
+    QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
+    QString pathEnv = env.value("PATH");
+
+    // Split the PATH by colon
+    QStringList pathDirs = pathEnv.split(":", QString::SkipEmptyParts);
+
+    // Check each directory in the PATH
+    foreach (const QString &dir, pathDirs) {
+        QFileInfo fileInfo(QDir(dir).filePath(command));
+
+        // If the file exists and is executable, return the path
+        if (fileInfo.exists() && fileInfo.isExecutable()) {
+            return fileInfo.absoluteFilePath();
+        }
+    }
+
+    return QString::null;
+}
+
 QString Gpg::initGpgExec()
 {
-    QString path =  QDir::currentPath().append("/lib/bin/gpg");
+    QString path = findCommandPath("gpg");
-    QFileInfo file(path);
+    if (path.isNull()) {
-    if (!file.isFile()) {
+        qFatal("No valid gpg exec found !");
-        qFatal("GNUPGEXEC file not found !");
-    }
-    if (!file.isExecutable()) {
-        qFatal("GNUPGEXEC file not executable !");
     }
     return path;
 }
@@ -82,53 +105,55 @@ QString Gpg::initGpgExec()
 
 void Gpg::initGpgConfig()
 {
-    auto home = initGpgHome();
+    initializeLibrary();
-    auto exec = initGpgExec();
+    gpgme_set_global_flag("disable-gpgconf", "1");
+
+    QString home = initGpgHome();
+    qDebug() << "Gpg home is " << home;
+    QString exec = initGpgExec();
+    qDebug() << "Gpg exec is " << exec;
 
     QFile agentConf(home + QStringLiteral("/gpg-agent.conf"));
     agentConf.remove();
     agentConf.open(QIODevice::WriteOnly);
-    agentConf.write("allow-loopback-pinentry");
+    agentConf.write("allow-loopback-pinentry\n");
     agentConf.close();
 
-    gpgme_set_engine_info (
+    auto err = gpgme_set_engine_info (
-        GPGME_PROTOCOL_OpenPGP,
+                   GPGME_PROTOCOL_OpenPGP,
-        exec.toLocal8Bit().data(),
+                   exec.toLocal8Bit().data(),
-        home.toLocal8Bit().data()
+                   home.toLocal8Bit().data()
-    );
+               );
+    if (err != GPG_ERR_NO_ERROR) {
+        qDebug() << "Error code : " << err;
+        qDebug() << "Error str : " << gpg_strerror(err);
+        qFatal("GPGME set engine info failed !");
+    }
 }
 
 
-QPair<Error, QString> Gpg::decrypt(QByteArray cipherText)
+Error Gpg::decrypt(QByteArray cipher_text)
 {
     auto job = openpgp()->decryptJob();
+
     auto ctx = DecryptJob::context(job);
 
-    auto provider = new UTPassphraseProvider;
+    ctx->setPassphraseProvider(this->m_passphrase_provider);
-    ctx->setPassphraseProvider(provider);
     ctx->setPinentryMode(Context::PinentryLoopback);
 
-    QByteArray plain_text;
+    QObject::connect(job, &DecryptJob::result,
-    auto decResult = job->exec(cipherText, plain_text);
+                     this, &Gpg::decryptResultSlot);
 
-    delete job;
+    return job->start(cipher_text);
-
-    if (decResult.error()) {
-        qWarning() << "something gone wrong on decrypt";
-        qDebug() << "Code Error : " << decResult.error().code();
-        qDebug() << "Error str : " << decResult.error().asString();
-    }
-    return QPair<Error, QString>(decResult.error(), QString::fromUtf8(plain_text));
 }
 
-
+Error Gpg::decryptFromFile(QString path)
-QPair<Error, QString> Gpg::decryptFromFile(QString path)
 {
     qDebug() << "Decrypt from " << path;
     QFile file(path);
     if (!file.open(QIODevice::ReadOnly)) {
         qWarning() << "Can't open the File";
-        return QPair<Error, QString>(Error(), QString());;
+        return Error();
     }
     QByteArray cipherText = file.readAll();
     file.close();
@@ -136,77 +161,85 @@ QPair<Error, QString> Gpg::decryptFromFile(QString path)
 }
 
 
-QPair<Error, QByteArray> Gpg::encrypt(QString str, QString uid, bool ascii_armor, bool text_mode)
+
+void Gpg::decryptResultSlot(const GpgME::DecryptionResult &result, const QByteArray &plainText,
+                            const QString &auditLogAsHtml, const GpgME::Error &auditLogError)
 {
-
+    if (result.error()) {
-    qDebug() << "Encrypt to QByteArray";
+        qWarning() << "Something gone wrong on decrypt";
-    auto keys = getKeys(uid);
+        qDebug() << "Code Error : " << result.error().code();
-    if (keys.first) {
+        qDebug() << "Error str : " << result.error().asString();
-        return QPair<Error, QByteArray>(keys.first, QByteArray());
     }
-
+    emit decryptResult(result.error(), QString::fromUtf8(plainText));
-    auto job = std::unique_ptr<EncryptJob>(openpgp()->encryptJob(ascii_armor, text_mode));
-
-    QByteArray cipherText;
-    auto result = job->exec(keys.second, str.toUtf8(), Context::AlwaysTrust, cipherText);
-
-    qDebug() << "Encrypted to QByteArray";
-    return QPair<Error, QByteArray>(result.error(), cipherText);
 }
 
 
-Error Gpg::encryptToFile(QString str, QString path, QString uid, bool ascii_armor,
+// QPair<Error, QByteArray> Gpg::encrypt(QString str, QString uid, bool ascii_armor, bool text_mode)
-                         bool text_mode)
+// {
-{
+
-    qDebug() << "Encrypting to file  " << path;
+//     qDebug() << "Encrypt to QByteArray";
-    QFile file(path);
+//     auto keys = getKeys(uid);
-    if (!file.open(QIODevice::WriteOnly)) {
+//     if (keys.first) {
-        qWarning() << "Can't open the file to write it" ;
+//         return QPair<Error, QByteArray>(keys.first, QByteArray());
-        return Error();
+//     }
-    }
+
-    auto encrypt_ret = encrypt(str, uid, ascii_armor, text_mode);
+//     auto job = std::unique_ptr<EncryptJob>(openpgp()->encryptJob(ascii_armor, text_mode));
-    if (encrypt_ret.first) {
+
-        file.write(encrypt_ret.second);
+//     QByteArray cipherText;
-    }
+//     auto result = job->exec(keys.second, str.toUtf8(), Context::AlwaysTrust, cipherText);
-    qDebug() << "Encrypting to file  " << path;
+
-    return encrypt_ret.first;
+//     qDebug() << "Encrypted to QByteArray";
-}
+//     return QPair<Error, QByteArray>(result.error(), cipherText);
+// }
 
 
-QPair<Error, std::vector< GpgME::Key >> Gpg::getAllKeys ( bool remote, const bool include_sigs,
+// Error Gpg::encryptToFile(QString str, QString path, QString uid, bool ascii_armor,
-                                                          bool validate )
+//                          bool text_mode)
+// {
+//     qDebug() << "Encrypting to file  " << path;
+//     QFile file(path);
+//     if (!file.open(QIODevice::WriteOnly)) {
+//         qWarning() << "Can't open the file to write it" ;
+//         return Error();
+//     }
+//     auto encrypt_ret = encrypt(str, uid, ascii_armor, text_mode);
+//     if (encrypt_ret.first) {
+//         file.write(encrypt_ret.second);
+//     }
+//     qDebug() << "Encrypting to file  " << path;
+//     return encrypt_ret.first;
+// }
+
+
+Error Gpg::getAllKeys ( bool remote, const bool include_sigs,
+                        bool validate )
 {
     return getKeys(QString(""), remote, include_sigs, validate);
 }
 
-QPair<Error, std::vector<Key>> Gpg::getKeys(QString pattern_uid, bool remote, bool include_sigs,
+Error Gpg::getKeys(QString pattern_uid, bool remote, bool include_sigs,
-                                            bool validate)
+                   bool validate)
 {
     qDebug() << "Getting the keys " << pattern_uid;
-    auto job = std::unique_ptr<KeyListJob>(openpgp()->keyListJob(remote, include_sigs, validate));
+    auto job = openpgp()->keyListJob(remote, include_sigs, validate);
 
-    std::vector<Key> keys;
+    QObject::connect(job, &KeyListJob::result,
-    auto result = job->exec(QStringList() << pattern_uid, false, keys);
+                     this, &Gpg::getKeysJobResultSlot);
 
-    qDebug() << "Got the keys " << pattern_uid;
+    return job->start(QStringList() << pattern_uid, false);
-    return QPair<Error, std::vector< Key >>(result.error(), keys);
 }
 
-
+void Gpg::getKeysJobResultSlot(const GpgME::KeyListResult &result, const std::vector<GpgME::Key> &keys,
-QPair<Error, Key> Gpg::getKey(QString uid, bool remote, bool include_sigs, bool validate)
+                               const QString &auditLogAsHtml, const GpgME::Error &auditLogError)
 {
-    qDebug() << "Getting the key " << uid;
+    if (result.error()) {
-    auto keys = getKeys(uid, remote, include_sigs, validate);
+        qWarning() << "Something gone wrong on decrypt";
-
+        qDebug() << "Code Error : " << result.error().code();
-    if (keys.first or keys.second.size() != 1) {
+        qDebug() << "Error str : " << result.error().asString();
-        qWarning() << "Bad id";
-        return QPair<Error, Key>(keys.first, Key::null);
     }
-    qDebug() << "Got the key " << uid;
+    emit getKeysResult(result.error(), keys);
-    return QPair<Error, Key>(keys.first, keys.second.front());
 }
 
-
 Error Gpg::importKeysFromFile(QString path)
 {
     qDebug() << "Importing the key file" << path;
@@ -216,55 +249,54 @@ Error Gpg::importKeysFromFile(QString path)
         qWarning() << "Can't open the File";
         return Error();
     }
+    auto data = file.readAll();
+    file.close();
 
     auto job = openpgp()->importJob();
-    auto ctx = ImportJob::context(job);
 
-    auto provider = new UTPassphraseProvider;
+    QObject::connect(job, &ImportJob::result,
-    ctx->setPassphraseProvider(provider);
+                     this, &Gpg::importKeysFromFileSlot);
-    ctx->setPinentryMode(Context::PinentryLoopback);
-    auto result = job->exec(file.readAll());
 
+
+    return job->start(data);
+}
+
+void Gpg::importKeysFromFileSlot(const GpgME::ImportResult &result, const QString &auditLogAsHtml,
+                                 const GpgME::Error &auditLogError)
+{
     qDebug() << "numImported" << result.numImported();
     qDebug() << "numSecretKeysImported" << result.numSecretKeysImported();
     qDebug() << "numSecretKeysConsidered" << result.numSecretKeysConsidered();
     qDebug() << "numSecretKeysUnchanged" << result.numSecretKeysUnchanged();
     qDebug() << "numUnchanged" << result.numUnchanged();
 
-    file.close();
-    delete job;
-    delete provider;
 
     if (result.error()) {
-        qWarning() << "Import go wrong";
+        qWarning() << "Something gone wrong on decrypt";
         qDebug() << "Code Error : " << result.error().code();
         qDebug() << "Error str : " << result.error().asString();
     }
-    qDebug() << "Imported the key file" << path;
+    emit importKeysFromFileResult(result.error());
-    return result.error();
 }
 
-Error Gpg::deleteKeyId(QString uid)
+Error Gpg::deleteKey(const Key key)
 {
-    qDebug() << "Deleting key id " << uid;
+    auto job = openpgp()->deleteJob();
-    auto key = getKey(uid);
 
-    if (key.first) {
+    QObject::connect(job, &DeleteJob::result,
-        return key.first;
+                     this, &Gpg::deleteKeySlot);
-    }
 
-    auto ctx = std::unique_ptr<Context>(Context::createForProtocol(OpenPGP));
+    return openpgp()->deleteJob()->start(key, true);
-    auto err = ctx->deleteKey(key.second, true);
-
-    if (err) {
-        qWarning() << "Delete go wrong";
-        qDebug() << "Code Error : " << err.code();
-        qDebug() << "Error str : " << err.asString();
-        return err;
-    }
-
-    qDebug() << "Deleted key id" << uid;
-    return err;
 }
 
+void Gpg::deleteKeySlot(const GpgME::Error &error, const QString &auditLogAsHtml, const GpgME::Error &auditLogError)
+{
+
+    if (error) {
+        qWarning() << "Something gone wrong on decrypt";
+        qDebug() << "Code Error : " << error.code();
+        qDebug() << "Error str : " << error.asString();
+    }
+    emit deleteKeyResult(error);
+}
 

plugins/Pass/gpg.h

@@ -1,61 +1,228 @@
 #ifndef GPG_H
 #define GPG_H
 
+#include "passkeymodel.h"
+#include "passphraseprovider.h"
 #include <memory>
 #include <QQuickWindow>
 #include <gpgme++/context.h>
 #include <qgpgme/changeownertrustjob.h>
+#include <QSemaphore>
+
+#include <gpgme.h>
+#include <qgpgme/importjob.h>
+#include <qgpgme/deletejob.h>
+#include <qgpgme/decryptjob.h>
+#include <qgpgme/encryptjob.h>
+#include <qgpgme/protocol.h>
+#include <qgpgme/keylistjob.h>
+#include <qgpgme/changeownertrustjob.h>
 
 
 using namespace GpgME;
+using namespace QGpgME;
 
-class Gpg
+/**
+ * @class Gpg
+ * @brief A class for managing GPG key operations such as key import, decryption, and deletion.
+ *
+ * This class integrates with the GPGME (GnuPG Made Easy) library to provide functionalities
+ * for interacting with GPG keys, including decrypting messages, importing keys from files,
+ * listing keys, and deleting keys. The class also provides slots for handling results
+ * of asynchronous GPG operations and communicates with the user via signals.
+ */
+class Gpg: public QObject
 {
-private:
+    Q_OBJECT
-    Gpg();
+    Q_PROPERTY(UTPassphraseProvider* passphrase_provider READ passphrase_provider MEMBER  m_passphrase_provider )
-    QObject *m_window;
 
+private slots:
+    /**
+     * @brief Slot to handle the result of a decryption operation.
+     * @param result The result of the decryption operation.
+     * @param plain_text The decrypted text.
+     * @param auditLogAsHtml The HTML formatted audit log for the operation.
+     * @param auditLogError The error associated with the audit log, if any.
+     */
+    void decryptResultSlot(
+        const DecryptionResult &result,
+        const QByteArray &plain_text,
+        const QString &auditLogAsHtml,
+        const Error &auditLogError
+    );
+
+    /**
+     * @brief Slot to handle the result of a key retrieval operation.
+     * @param result The result of the key retrieval operation.
+     * @param keys A vector of keys retrieved.
+     * @param auditLogAsHtml The HTML formatted audit log for the operation, if any.
+     * @param auditLogError The error associated with the audit log, if any.
+     */
+    void getKeysJobResultSlot(
+        const GpgME::KeyListResult &result,
+        const std::vector<GpgME::Key> &keys,
+        const QString &auditLogAsHtml,
+        const GpgME::Error &auditLogError
+    );
+
+    /**
+     * @brief Slot to handle the result of a key import operation.
+     * @param result The result of the import operation.
+     * @param auditLogAsHtml The HTML formatted audit log for the operation, if any.
+     * @param auditLogError The error associated with the audit log, if any.
+     */
+    void importKeysFromFileSlot(
+        const GpgME::ImportResult &result,
+        const QString &auditLogAsHtml,
+        const GpgME::Error &auditLogError
+    );
+
+    /**
+     * @brief Slot to handle the result of a key deletion operation.
+     * @param result The error result of the deletion operation.
+     * @param auditLogAsHtml The HTML formatted audit log for the operation, if any.
+     * @param auditLogError The error associated with the audit log, if any.
+     */
+    void deleteKeySlot(
+        const GpgME::Error &result,
+        const QString &auditLogAsHtml,
+        const GpgME::Error &auditLogError
+    );
+
+signals:
+    /**
+     * @brief Signal emitted when keys are imported from a file.
+     * @param err The error that occurred during the import operation, if any.
+     */
+    void importKeysFromFileResult(Error err);
+
+    /**
+     * @brief Signal emitted when keys are retrieved.
+     * @param err The error that occurred during the retrieval operation, if any.
+     * @param keys A vector of keys retrieved.
+     */
+    void getKeysResult(Error err, std::vector<GpgME::Key> keys);
+
+    /**
+     * @brief Signal emitted when a key is deleted.
+     * @param err The error that occurred during the deletion operation, if any.
+     */
+    void deleteKeyResult(Error err);
+
+    /**
+     * @brief Signal emitted when a decryption operation completes.
+     * @param err The error that occurred during decryption, if any.
+     * @param plain_text The decrypted message.
+     */
+    void decryptResult(Error err, QString plain_text);
+
+private:
+    UTPassphraseProvider *m_passphrase_provider; /**< The passphrase provider used for authentication. */
+
+    /**
+     * @brief Finds the path of a command in the system's environment.
+     * @param command The name of the command to find.
+     * @return The full path to the command.
+     */
+    QString findCommandPath(const QString &command);
+
+    /**
+     * @brief Initializes the GPG home directory.
+     * @return The path to the GPG home directory.
+     */
     QString initGpgHome();
+
+    /**
+     * @brief Initializes the GPG executable path.
+     * @return The path to the GPG executable.
+     */
     QString initGpgExec();
+
+    /**
+     * @brief Initializes the GPG configuration.
+     */
     void initGpgConfig();
 
+    /**
+     * @brief Retrieves a GPG key by UID.
+     * @param uid The UID of the key to retrieve.
+     * @param remote Whether to fetch the key from a remote keyserver (default: false).
+     * @param include_sigs Whether to include signatures (default: false).
+     * @param validate Whether to validate the key (default: false).
+     * @return The error result of the operation.
+     */
+    Error getKey(QString uid, bool remote = false, bool include_sigs = false, bool validate = false);
+
 public:
+    /**
+     * @brief Constructs a Gpg object and initializes necessary resources.
+     * @param window The window object for interacting with the user interface.
+     */
+    Gpg(QObject* window);
+
+    /**
+     * @brief Destroys the Gpg object and cleans up resources.
+     */
     ~Gpg();
 
-    static std::shared_ptr<Gpg> instance()
+    /**
+     * @brief Gets the passphrase provider used for GPG authentication.
+     * @return The passphrase provider.
+     */
+    UTPassphraseProvider *passphrase_provider() const
     {
-        static std::shared_ptr<Gpg> s{new Gpg};
+        return m_passphrase_provider;
-        return s;
     }
-    Gpg(Gpg const &) = delete;
-    void operator=(Gpg const &) = delete;
-
-    void setWindow(QObject *window)
-    {
-        m_window = window;
-    };
-
-    QObject *getWindow()
-    {
-        return m_window;
-    };
 
 
-    QPair< Error, std::vector< Key > > getAllKeys(bool remote = false, bool include_sigs = {}, bool
+    /**
-                                                  validate = false);
+     * @brief Imports GPG keys from a file.
-    QPair<Error, std::vector<Key>> getKeys( QString pattern_uid,  bool remote = false,
+     * @param path The path to the file containing the keys.
-                                            bool include_sigs = false,
+     * @return The error result of the import operation.
-                                            bool validate = false);
+     */
-    QPair<Error, Key> getKey( QString uid,  bool remote = false,  bool include_sigs = false,
+    Error importKeysFromFile(const QString path);
-                              bool validate = false);
+
-    QPair<Error, QString>  decrypt( QByteArray cipherText);
+    /**
-    QPair<Error, QString> decryptFromFile( QString path);
+     * @brief Retrieves keys matching the provided UID pattern.
-    QPair<Error, QByteArray> encrypt( QString str,  QString uid,  bool ascii_armor = true,
+     * @param pattern_uid The UID pattern to search for.
-                                      bool text_mode = true);
+     * @param remote Whether to fetch the key from a remote keyserver (default: false).
-    Error encryptToFile( QString str,  QString path,  QString uid,  bool ascii_armor = true,
+     * @param include_sigs Whether to include signatures (default: false).
-                         bool text_mode = true);
+     * @param validate Whether to validate the key (default: false).
-    Error importKeysFromFile( QString path);
+     * @return The error result of the operation.
-    Error deleteKeyId( QString uid);
+     */
+    Error getKeys(const QString pattern_uid, bool remote = false, bool include_sigs = false, bool validate = false);
+
+    /**
+     * @brief Retrieves all keys from the GPG keyring.
+     * @param remote Whether to fetch the keys from a remote keyserver (default: false).
+     * @param include_sigs Whether to include signatures (default: false).
+     * @param validate Whether to validate the keys (default: false).
+     * @return The error result of the operation.
+     */
+    Error getAllKeys(bool remote = false, bool include_sigs = false, bool validate = false);
+
+    /**
+     * @brief Deletes a specified GPG key.
+     * @param key The key to delete.
+     * @return The error result of the deletion operation.
+     */
+    Error deleteKey(const Key key);
+
+    /**
+     * @brief Decrypts a given ciphertext.
+     * @param cipher_text The ciphertext to decrypt.
+     * @return The error result of the decryption operation.
+     */
+    Error decrypt(const QByteArray cipher_text);
+
+    /**
+     * @brief Decrypts the contents of a file.
+     * @param path The path to the file to decrypt.
+     * @return The error result of the decryption operation.
+     */
+    Error decryptFromFile(const QString path);
+
+    // Error encrypt (QString str,  QString uid,  bool ascii_armor = true, bool text_mode = true);
 };
 
 #endif

plugins/Pass/pass.cpp

@@ -4,63 +4,124 @@
 
 #include "pass.h"
 #include "gpg.h"
-#include "passphraseprovider.h"
 #include "passkeymodel.h"
 
 
 
-Pass::Pass(): m_password_store (QStandardPaths::writableLocation(
+Pass::Pass():
-                                        QStandardPaths::AppDataLocation).append("/.password-store"))
+    m_password_store (QStandardPaths::writableLocation(
+                          QStandardPaths::AppDataLocation).append("/.password-store")),
+    m_sem(std::unique_ptr<QSemaphore>(new QSemaphore(1))),
+    m_show_filename(QString())
 {}
 
-void Pass::init(QObject *window)
+void Pass::initialize(QObject *window)
 {
     if (!window) {
         qFatal("window is invalid. Abording.");
     }
-    Gpg::instance()->setWindow(window);
+
+    this->m_gpg = std::unique_ptr<Gpg>(new Gpg(window));
+
+    QObject::connect(this, &Pass::responsePassphraseDialogPropagate, this->m_gpg->passphrase_provider(),
+                     &UTPassphraseProvider::handleResponse);
+    QObject::connect(this->m_gpg.get(), &Gpg::importKeysFromFileResult, this, &Pass::importGPGKeyResult);
+    QObject::connect(this->m_gpg.get(), &Gpg::getKeysResult, this, &Pass::getAllGPGKeysResult);
+    QObject::connect(this->m_gpg.get(), &Gpg::deleteKeyResult, this, &Pass::deleteGPGKeyResult);
+    QObject::connect(this->m_gpg.get(), &Gpg::decryptResult, this, &Pass::showResult);
 
     QDir dir(m_password_store);
-    if (!dir.exists())
+    if (!dir.exists()) {
         dir.mkpath(".");
-    qDebug() << "Password Store is :" << m_password_store;
-}
-
-void Pass::decrypt(QUrl url)
-{
-    qDebug() << "Start decrypting";
-    auto decrypt_ret = Gpg::instance()->decryptFromFile(url.toLocalFile());
-    if (decrypt_ret.first) {
-        qDebug() << "Decrypt Failed";
-        emit decryptFailed();
-    } else if (decrypt_ret.second.isNull()) {
-        qDebug() << "Decrypt Canceled";
-        emit decryptCanceled();
-    } else {
-        qDebug() << "Decrypt OK";
-        emit decrypted(decrypt_ret.second);
     }
+    qInfo() << "Password Store is :" << m_password_store;
 }
 
-bool Pass::gpgDeleteKeyId(QString id)
+bool Pass::show(QUrl url)
 {
-    qDebug() << "Start deleting Key id " << id;
+    if (!this->m_sem->tryAcquire(1, 500)) {
-    return !Gpg::instance()->deleteKeyId(id);
+        return false;
+    }
+    auto path = url.toLocalFile();
+    qInfo() << "Staring decrypting job for " << path;
+    QFileInfo file_info(path);
+    this->m_show_filename = file_info.completeBaseName();
+    return this->m_gpg->decryptFromFile(path);
 }
 
-bool Pass::gpgImportKeyFromFile(QUrl url)
+void Pass::showResult(Error err, QString plain_text)
 {
-    qDebug() << "Start importing Key from " << url;
+    qInfo() << "Result for decrypting job";
-    return !Gpg::instance()->importKeysFromFile(url.toLocalFile());
+    if (err) {
+        qInfo() << "Decrypt Failed";
+        emit showFailed(err.asString());
+    } else {
+        qInfo() << "Decrypt OK";
+        emit showSucceed(this->m_show_filename, plain_text);
+    }
+    this->m_show_filename = QString();
+    this->m_sem->release(1);
 }
 
-QVariant Pass::gpgGetAllKeysModel()
+bool Pass::deleteGPGKey(Key key)
 {
-    return QVariant::fromValue(PassKeyModel::keysToPassKeyQObjectList(
+    if (!this->m_sem->tryAcquire(1, 500)) {
-                                   Gpg::instance()->getAllKeys().second));
+        return false;
+    }
+    qInfo() << "Deleting Key";
+    return this->m_gpg->deleteKey(key);
 }
 
-QString Pass::getPasswordStore()
+void Pass::deleteGPGKeyResult(Error err)
 {
-    return m_password_store;
+    if (err) {
+        emit deleteGPGKeyFailed(err.asString());
+    } else {
+        emit deleteGPGKeySucceed();
+    }
+    this->m_sem->release(1);
+}
+
+bool Pass::importGPGKey(QUrl url)
+{
+    if (!this->m_sem->tryAcquire(1, 500)) {
+        return false;
+    }
+    qInfo() << "Importing Key from " << url;
+    return this->m_gpg->importKeysFromFile(url.toLocalFile());
+}
+
+void Pass::importGPGKeyResult(Error err)
+{
+    if (err) {
+        emit importGPGKeyFailed(err.asString());
+    } else {
+        emit importGPGKeySucceed();
+    }
+    this->m_sem->release(1);
+}
+
+bool Pass::getAllGPGKeys()
+{
+    if (!this->m_sem->tryAcquire(1, 500)) {
+        return false;
+    }
+    qInfo() << "Getting all key form gpg ";
+    return this->m_gpg->getAllKeys();
+}
+
+void Pass::getAllGPGKeysResult(Error err,  std::vector<GpgME::Key> keys_info)
+{
+    if (err) {
+        emit getAllGPGKeysFailed(err.asString());
+    } else {
+        emit getAllGPGKeysSucceed(QVariant::fromValue(PassKeyModel::keysToPassKey(keys_info)));
+    }
+    this->m_sem->release(1);
+}
+
+void Pass::responsePassphraseDialog(bool cancel, QString passphrase)
+{
+    qDebug() << "responsePassphraseDialog";
+    emit responsePassphraseDialogPropagate(cancel, passphrase);
 }

plugins/Pass/pass.h

@@ -4,29 +4,180 @@
 #include <QObject>
 #include <QUrl>
 #include <QVariant>
+#include <gpgme++/context.h>
 
+#include "gpg.h"
 
+using namespace GpgME;
+
+/**
+ * @class Pass
+ * @brief A class for managing password storage using GPG encryption.
+ *
+ * This class provides functionalities for interacting with password storage, including
+ * storing, showing, importing, and deleting passwords securely using GPG encryption.
+ * It communicates asynchronously with GPG operations, using signals and slots to propagate results.
+ * The class interacts with the `Gpg` class to perform GPG key operations and provides an interface
+ * for the user to manage the passwords.
+ */
 class Pass : public QObject
 {
     Q_OBJECT
-    QString m_password_store;
+    Q_PROPERTY(QString password_store READ password_store MEMBER m_password_store CONSTANT)
+
+private slots:
+    /**
+     * @brief Slot to handle the result of a GPG decryption operation (to show password).
+     * @param err The error that occurred during the operation.
+     * @param plain_text The decrypted plain text (password).
+     */
+    void showResult(Error err, QString plain_text);
+
+    /**
+     * @brief Slot to handle the result of a GPG key deletion operation.
+     * @param err The error that occurred during the operation.
+     */
+    void deleteGPGKeyResult(Error err);
+
+    /**
+     * @brief Slot to handle the result of a GPG key import operation.
+     * @param err The error that occurred during the operation.
+     */
+    void importGPGKeyResult(Error err);
+
+    /**
+     * @brief Slot to handle the result of retrieving all GPG keys.
+     * @param err The error that occurred during the operation.
+     * @param keys_info The list of GPG keys retrieved.
+     */
+    void getAllGPGKeysResult(Error err, std::vector<GpgME::Key> keys_info);
 
 signals:
-    void decrypted(QString text);
+    // GPG-related signals
-    void decryptCanceled();
+    /**
-    void decryptFailed();
+     * @brief Emitted when a GPG key is successfully deleted.
+     */
+    void deleteGPGKeySucceed();
 
+    /**
+     * @brief Emitted when a GPG key deletion fails.
+     * @param message The error message describing the failure.
+     */
+    void deleteGPGKeyFailed(QString message);
+
+    /**
+     * @brief Emitted when a GPG key is successfully imported.
+     */
+    void importGPGKeySucceed();
+
+    /**
+     * @brief Emitted when a GPG key import fails.
+     * @param message The error message describing the failure.
+     */
+    void importGPGKeyFailed(QString message);
+
+    /**
+     * @brief Emitted when all GPG keys are successfully retrieved.
+     * @param keys_info The list of retrieved keys.
+     */
+    void getAllGPGKeysSucceed(QVariant keys_info);
+
+    /**
+     * @brief Emitted when retrieving GPG keys fails.
+     * @param message The error message describing the failure.
+     */
+    void getAllGPGKeysFailed(QString message);
+
+    // Pass-related signals
+    /**
+     * @brief Emitted to propagate passphrase dialog response.
+     * @param cancel Whether the dialog was cancelled.
+     * @param passphrase The passphrase entered, if not cancelled.
+     */
+    void responsePassphraseDialogPropagate(bool cancel, QString passphrase);
+
+    /**
+     * @brief Emitted when a password is successfully retrieved and shown.
+     * @param name The name of the password (e.g., service).
+     * @param text The password text.
+     */
+    void showSucceed(QString name, QString text);
+
+    /**
+     * @brief Emitted when showing a password fails.
+     * @param message The error message describing the failure.
+     */
+    void showFailed(QString message);
+
+private:
+    QString m_password_store; /**< The path to the password store. */
+    std::unique_ptr<Gpg> m_gpg; /**< The GPG instance used for encryption/decryption. */
+    std::unique_ptr<QSemaphore> m_sem; /**< Semaphore for managing concurrent operations. */
+    QString m_show_filename; /**< The filename associated with the password to show. */
 
 public:
+    /**
+     * @brief Constructs the Pass object and initializes necessary resources.
+     */
     Pass();
+
+    /**
+     * @brief Destructor for cleaning up resources used by the Pass object.
+     */
     ~Pass() override = default;
 
-    Q_INVOKABLE void init(QObject *window);
+    /**
-    Q_INVOKABLE QString getPasswordStore();
+     * @brief Gets the path to the password store.
-    Q_INVOKABLE void decrypt(QUrl url);
+     * @return The path to the password store.
-    Q_INVOKABLE bool gpgDeleteKeyId(QString id);
+     */
-    Q_INVOKABLE bool gpgImportKeyFromFile(QUrl url);
+    QString password_store() const
-    Q_INVOKABLE QVariant gpgGetAllKeysModel();
+    {
+        return m_password_store;
+    };
+
+    /**
+     * @brief Initializes the Pass object with the given window.
+     * @param window The QObject window to interact with.
+     */
+    Q_INVOKABLE void initialize(QObject *window);
+
+    // GPG-related methods
+
+    /**
+     * @brief Deletes the specified GPG key.
+     * @param key The GPG key to delete.
+     * @return True if the operation was successful, false otherwise.
+     */
+    Q_INVOKABLE bool deleteGPGKey(Key key);
+
+    /**
+     * @brief Imports a GPG key from the given URL.
+     * @param url The URL to import the GPG key from.
+     * @return True if the operation was successful, false otherwise.
+     */
+    Q_INVOKABLE bool importGPGKey(QUrl url);
+
+    /**
+     * @brief Retrieves all GPG keys.
+     * @return True if the operation was successful, false otherwise.
+     */
+    Q_INVOKABLE bool getAllGPGKeys();
+
+    /**
+     * @brief Return the response from the passphrase dialog.
+     * @param cancel Whether the dialog was cancelled.
+     * @param passphrase The passphrase entered, if not cancelled.
+     */
+    Q_INVOKABLE void responsePassphraseDialog(bool cancel, QString passphrase);
+
+    // Password store-related methods
+
+    /**
+     * @brief Shows the password associated with the specified URL.
+     * @param url The URL pointing to the password store entry.
+     * @return True if the operation was successful, false otherwise.
+     */
+    Q_INVOKABLE bool show(QUrl url);
 };
 
 #endif

plugins/Pass/passkeymodel.h

@@ -6,69 +6,149 @@
 
 using namespace GpgME;
 
+/**
+ * @class UserIdModel
+ * @brief A model representing a user ID associated with a GPG key.
+ *
+ * This class encapsulates the user ID information (UID) for a GPG key, providing access
+ * to the UID's identifier, name, and email. It is used as a model for user IDs in the
+ * `PassKeyModel` class.
+ */
+class UserIdModel : public QObject
+{
+    Q_OBJECT
+    Q_PROPERTY(QString uid READ uid CONSTANT)
+    Q_PROPERTY(QString name READ name CONSTANT)
+    Q_PROPERTY(QString email READ email CONSTANT)
+
+private:
+    UserID m_user_id; /**< The GPG UserID associated with the model. */
+
+public:
+    /**
+     * @brief Constructs a UserIdModel for the given UserID.
+     * @param key The GPG UserID to model.
+     */
+    UserIdModel(UserID key) : m_user_id(key) {}
+
+    /**
+     * @brief Gets the unique identifier (UID) for this user ID.
+     * @return The UID as a QString.
+     */
+    QString uid() const
+    {
+        return QString::fromUtf8(m_user_id.id());
+    };
+
+    /**
+     * @brief Gets the name associated with this user ID.
+     * @return The name as a QString.
+     */
+    QString name() const
+    {
+        return QString::fromUtf8(m_user_id.name());
+    };
+
+    /**
+     * @brief Gets the email associated with this user ID.
+     * @return The email as a QString.
+     */
+    QString email() const
+    {
+        return QString::fromUtf8(m_user_id.email());
+    };
+};
+
+/**
+ * @class PassKeyModel
+ * @brief A model representing a GPG key.
+ *
+ * This class encapsulates the properties of a GPG key, including its key ID, associated
+ * user IDs, secret key status, and expiration status. It is used as a model for managing
+ * GPG keys within an application, providing access to the key's data and its associated user IDs.
+ */
 class PassKeyModel : public QObject
 {
     Q_OBJECT
-    Q_PROPERTY(QString uid READ uid WRITE setUid NOTIFY uidChanged MEMBER m_uid)
+    Q_PROPERTY(Key key READ key MEMBER m_key CONSTANT)
-    Q_PROPERTY(bool secret READ secret WRITE setSecret NOTIFY secretChanged MEMBER m_secret)
+    Q_PROPERTY(QString uid READ uid CONSTANT)
-    Q_PROPERTY(bool expired READ expired WRITE setExpired NOTIFY expiredChanged MEMBER m_expired)
+    Q_PROPERTY(QList<QObject *> userIds READ userIds CONSTANT)
+    Q_PROPERTY(bool isSecret READ isSecret CONSTANT)
+    Q_PROPERTY(bool isExpired READ isExpired CONSTANT)
 
-    QString m_uid;
+private:
-    bool m_secret;
+    Key m_key; /**< The GPG key associated with the model. */
-    bool m_expired;
 
 public:
-    PassKeyModel(QString uid, bool secret, bool expired):
+    /**
-        m_uid(uid),
+     * @brief Constructs a PassKeyModel for the given GPG key.
-        m_secret(secret),
+     * @param key The GPG key to model.
-        m_expired(expired)
+     */
-    {};
+    PassKeyModel(Key key) : m_key(key) {}
 
-    PassKeyModel(Key key):
+    /**
-        PassKeyModel(QString::fromUtf8(key.keyID()), key.hasSecret(), key.isExpired())
+     * @brief Converts a vector of GPG keys into a list of PassKeyModel objects.
-    {};
+     * @param keys The vector of GPG keys to convert.
-
+     * @return A QList of PassKeyModel objects representing the keys.
-    static QList<QObject *> keysToPassKeyQObjectList(std::vector<Key> keys)
+     */
+    static QList<QObject *> keysToPassKey(std::vector<Key> keys)
     {
-        QList<QObject *> r;
+        QList<QObject *> ret;
-        std::for_each(keys.begin(), keys.end(), [&r](Key k) {
+        std::for_each(keys.begin(), keys.end(), [&ret](Key k) {
-            r.append(new PassKeyModel(k));
+            ret.append(new PassKeyModel(k));
         });
-        return r;
+        return ret;
     };
 
+    /**
+     * @brief Gets the GPG key associated with this model.
+     * @return The GPG key.
+     */
+    Key key() const
+    {
+        return m_key;
+    };
+
+    /**
+     * @brief Gets the unique identifier (UID) for this GPG key.
+     * @return The UID as a QString.
+     */
     QString uid() const
     {
-        return m_uid;
+        return QString::fromUtf8(m_key.keyID());
-    };
-    bool secret() const
-    {
-        return m_secret;
-    };
-    bool expired() const
-    {
-        return m_expired;
     };
 
-    void setUid(QString uid)
+    /**
+     * @brief Gets the list of user IDs associated with this GPG key.
+     * @return A list of UserIdModel objects representing the user IDs.
+     */
+    QList<QObject *> userIds() const
     {
-        m_uid = uid;
+        auto user_ids = m_key.userIDs();
-        emit uidChanged(uid);
+        QList<QObject *> ret;
-    }
+        std::for_each(user_ids.begin(), user_ids.end(), [&ret](UserID k) {
-    void setSecret(bool secret)
+            ret.append(new UserIdModel(k));
-    {
+        });
-        m_secret = secret;
+        return ret;
-        emit secretChanged(secret);
+    };
-    }
-    void setExpired(bool expired)
-    {
-        m_expired = expired;
-        emit expiredChanged(expired);
-    }
 
-signals:
+    /**
-    void uidChanged(QString);
+     * @brief Checks if the GPG key is a secret key.
-    void secretChanged(bool);
+     * @return True if the key is a secret key, false otherwise.
-    void expiredChanged(bool);
+     */
+    bool isSecret() const
+    {
+        return m_key.hasSecret();
+    };
+
+    /**
+     * @brief Checks if the GPG key is expired.
+     * @return True if the key is expired, false otherwise.
+     */
+    bool isExpired() const
+    {
+        return m_key.isExpired();
+    };
 };
+
 #endif

plugins/Pass/passphraseprovider.h

@@ -1,62 +1,113 @@
 #ifndef UTPASSPHRASEPROVIDER_H
 #define UTPASSPHRASEPROVIDER_H
 
+#include <QDebug>
 #include <stdio.h>
 #include <QObject>
 #include <QQmlProperty>
 #include <QEventLoop>
 #include <QSemaphore>
 #include <gpgme++/interfaces/passphraseprovider.h>
-#include "passphraseprovider.h"
 #include "gpg.h"
 
-
+/**
-
+ * @class UTPassphraseProvider
+ * @brief A passphrase provider for GPG operations that interacts with a QML dialog.
+ *
+ * This class implements the `PassphraseProvider` interface from GPGME and is responsible for
+ * obtaining passphrases for GPG operations. It does so by triggering a QML dialog to prompt the user
+ * for their passphrase. The response is then handled asynchronously, and the passphrase is returned to
+ * the calling GPGME function.
+ */
 class UTPassphraseProvider : public QObject, public PassphraseProvider
 {
     Q_OBJECT
-private:
-    std::unique_ptr<QEventLoop> m_loop;
-    std::unique_ptr<QSemaphore> m_sem;
-    char *m_passphrase;
-    bool m_canceled;
 
 public slots:
-    void handleResponse(bool canceled, QString p)
+    /**
+     * @brief Slot to handle the user's response from the passphrase dialog.
+     *
+     * This method processes the response from the passphrase dialog. If the user provides a passphrase,
+     * it is stored; if the operation is canceled, a flag is set.
+     *
+     * @param canceled Whether the user canceled the passphrase entry.
+     * @param passphrase The passphrase entered by the user.
+     */
+    void handleResponse(bool canceled, QString passphrase)
     {
+        qDebug() << "call handleResponse";
         if (!canceled)
-            gpgrt_asprintf(&m_passphrase, "%s", p.toUtf8().constData());
+            gpgrt_asprintf(&m_passphrase, "%s", passphrase.toUtf8().constData());
         else
             m_canceled = true;
-        m_loop->quit();
+        emit unlockEventLoop();
     };
 
+signals:
+    /**
+     * @brief Signal to unlock the event loop.
+     *
+     * This signal is emitted when the passphrase has been entered or the operation has been canceled,
+     * unlocking the event loop waiting for the response.
+     */
+    void unlockEventLoop();
+
+private:
+    std::unique_ptr<QSemaphore> m_sem; /**< Semaphore for managing access. */
+    char *m_passphrase; /**< The passphrase provided by the user. */
+    bool m_canceled; /**< Flag indicating whether the passphrase operation was canceled. */
+    QObject *m_window; /**< The window object that triggers the QML dialog. */
 
 public:
-    UTPassphraseProvider():
+    /**
-        m_loop(std::unique_ptr<QEventLoop>(new QEventLoop)),
+     * @brief Constructs a UTPassphraseProvider.
-        m_sem(std::unique_ptr<QSemaphore>(new QSemaphore(1))),
+     *
-        m_passphrase(nullptr),
+     * Initializes the semaphore, passphrase, and canceled flag. Sets the window object that will
-        m_canceled(false)
+     * trigger the passphrase dialog.
-    {}
+     *
+     * @param window The QObject representing the window that interacts with QML.
+     */
+    UTPassphraseProvider(QObject* window)
+        : m_sem(std::make_unique<QSemaphore>(1)),
+          m_passphrase(nullptr),
+          m_canceled(false),
+          m_window(window)
+    {
+        qDebug() << "Initialize UTPassphraseProvider";
+    }
 
-    char *getPassphrase( const char *useridHint,
+    /**
-                         const char *description,
+     * @brief Implements the PassphraseProvider's `getPassphrase` method.
-                         bool previousWasBad,
+     *
-                         bool &canceled ) Q_DECL_OVERRIDE {
+     * This method is called by GPGME to retrieve the passphrase needed for GPG operations. It triggers
-        if (!m_sem->tryAcquire(1, 3000))
+     * a QML dialog for the user to input their passphrase. The method waits for the response and returns
+     * the passphrase if successful, or null if canceled.
+     *
+     * @param useridHint A hint for the user ID to which the passphrase corresponds.
+     * @param description A description of the passphrase request.
+     * @param previousWasBad Flag indicating whether the previous passphrase attempt was incorrect.
+     * @param canceled Reference to a boolean flag that will be set if the operation is canceled.
+     *
+     * @return The passphrase as a `char *` or `nullptr` if canceled.
+     */
+    char *getPassphrase(const char *useridHint,
+                        const char *description,
+                        bool previousWasBad,
+                        bool &canceled) Q_DECL_OVERRIDE {
+        qDebug() << "Call the getPassphrase";
+        if (!this->m_sem->tryAcquire(1, 500))
         {
             qWarning() << "Cannot acquire UTPassphraseProvider semaphore.";
             canceled = true;
             return nullptr;
         }
 
-        m_passphrase = nullptr;
+        this->m_passphrase = nullptr;
-        m_canceled = false;
+        this->m_canceled = false;
 
         qDebug() << "Call the QML Dialog Passphrase Provider";
         QMetaObject::invokeMethod(
-            Gpg::instance()->getWindow(), "callPassphraseDialog",
+            this->m_window, "callPassphraseDialog",
             Q_ARG(QVariant, useridHint),
             Q_ARG(QVariant, description),
             Q_ARG(QVariant, previousWasBad)
@@ -64,25 +115,24 @@ public:
 
         qDebug() << "Waiting for response";
 
-        QObject::connect(
+        QEventLoop loop;
-            Gpg::instance()->getWindow(), SIGNAL(responsePassphraseDialog(bool, QString)),
+        QObject::connect(this, &UTPassphraseProvider::unlockEventLoop, &loop, &QEventLoop::quit);
-            this, SLOT(handleResponse(bool, QString))
+        loop.exec();
-        );
-        m_loop->exec();
 
         qDebug() << "Prepare Returns";
         char *ret;
         gpgrt_asprintf(&ret, "%s", m_passphrase);
-        canceled = m_canceled;
+        canceled = this->m_canceled;
 
         qDebug() << "Clean";
-        if (m_passphrase)
+        if (this->m_passphrase)
         {
             free(m_passphrase);
         }
-        m_canceled = false;
+        this->m_canceled = false;
-        m_sem->release(1);
+        this->m_sem->release(1);
         return ret;
     };
 };
+
 #endif

plugins/Utils/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
 set(PLUGIN "Utils")
 
 set(
@@ -23,15 +23,10 @@ add_library(${PLUGIN} MODULE ${SRC})
 set_target_properties(${PLUGIN} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PLUGIN})
 qt5_use_modules(${PLUGIN} Qml Quick DBus)
 
-set(EXTERNAL_LIBS "${CMAKE_SOURCE_DIR}/build/${ARCH_TRIPLET}/quazip/install/")
+add_library(libquazip5 SHARED IMPORTED)
-
+set_property(TARGET libquazip5 PROPERTY IMPORTED_LOCATION "/usr/lib/${ARCH_TRIPLET}/libquazip5.so")
-INCLUDE_DIRECTORIES(${EXTERNAL_LIBS}/include)
-
-add_library(quazip STATIC IMPORTED)
-set_property(TARGET quazip PROPERTY IMPORTED_LOCATION "${EXTERNAL_LIBS}/lib/libquazip5.a")
-
-target_link_libraries(${PLUGIN} quazip)
 
+target_link_libraries(${PLUGIN} libquazip5)
 
 set(QT_IMPORTS_DIR "/lib/${ARCH_TRIPLET}")
 

plugins/Utils/utils.cpp

@@ -7,8 +7,6 @@
 #include "utils.h"
 
 
-Utils::Utils() {};
-
 bool Utils::unzip(QUrl zip_url, QString dir_out_path)
 {
     auto tmp_dir_path =  QStandardPaths::writableLocation(
@@ -31,7 +29,7 @@ bool Utils::unzip(QUrl zip_url, QString dir_out_path)
 
     qDebug() << "Guessing if it should remove a single root folder";
     QStringList files_in_tmp_dir = tmp_dir.entryList(QDir::AllEntries | QDir::Hidden |
-                                                     QDir::NoDotAndDotDot);
+                                   QDir::NoDotAndDotDot);
 
     auto dir_import_path =
         files_in_tmp_dir.length() == 1 ?

plugins/Utils/utils.h

@@ -10,7 +10,7 @@ class Utils : public QObject
     Q_OBJECT
 
 public:
-    Utils();
+    Utils() = default;
     ~Utils() override = default;
 
     Q_INVOKABLE bool unzip(QUrl zip_url, QString dir_out);

po/utpass.qrouland.pot

@@ -1,5 +1,5 @@
-# UTPass  
+# SOME DESCRIPTIVE TITLE.
-# Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 # This file is distributed under the same license as the utpass.qrouland package.
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: utpass.qrouland\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2019-09-21 14:01+0000\n"
+"POT-Creation-Date: 2025-01-15 23:39+0100\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <LL@li.org>\n"
@@ -17,169 +17,209 @@ msgstr ""
 "Content-Type: text/plain; charset=CHARSET\n"
 "Content-Transfer-Encoding: 8bit\n"
 
-#: ../qml/components/FileDir.qml:71
-msgid "Decryption failed !"
-msgstr ""
-
-#: ../qml/dialogs/DoubleValidationDialog.qml:28
-#: ../qml/dialogs/PassphraseDialog.qml:29
-#: ../qml/dialogs/SimpleValidationDialog.qml:19
-msgid "Ok"
-msgstr ""
-
-#: ../qml/dialogs/DoubleValidationDialog.qml:44
-#: ../qml/dialogs/PassphraseDialog.qml:41
-#: ../qml/dialogs/SimpleValidationDialog.qml:30
-msgid "Cancel"
-msgstr ""
-
 #: ../qml/dialogs/ErrorDialog.qml:12
 msgid "Error !"
 msgstr ""
 
-#: ../qml/dialogs/ErrorDialog.qml:15 ../qml/dialogs/SuccessDialog.qml:15
+#: ../qml/dialogs/ErrorDialog.qml:16
-msgid "OK"
+msgid "Close"
 msgstr ""
 
-#: ../qml/dialogs/PassphraseDialog.qml:7
+#: ../qml/dialogs/PassphraseDialog.qml:15
 msgid "Authentication required"
 msgstr ""
 
-#: ../qml/dialogs/PassphraseDialog.qml:8
+#: ../qml/dialogs/PassphraseDialog.qml:16
 msgid "Enter passphrase:"
 msgstr ""
 
-#: ../qml/dialogs/PassphraseDialog.qml:20
+#: ../qml/dialogs/PassphraseDialog.qml:21
 msgid "passphrase"
 msgstr ""
 
+#: ../qml/dialogs/PassphraseDialog.qml:29
+#: ../qml/dialogs/SimpleValidationDialog.qml:9
+msgid "Ok"
+msgstr ""
+
+#: ../qml/dialogs/PassphraseDialog.qml:41
+#: ../qml/dialogs/SimpleValidationDialog.qml:34
+msgid "Cancel"
+msgstr ""
+
 #: ../qml/dialogs/SuccessDialog.qml:12
 msgid "Success !"
 msgstr ""
 
-#: ../qml/pages/headers/MainHeader.qml:8 ../qml/pages/headers/StackHeader.qml:8
+#: ../qml/dialogs/SuccessDialog.qml:16
-#: UTPass.desktop.in.h:1
+msgid "OK"
-msgid "UTPass"
 msgstr ""
 
-#: ../qml/pages/headers/MainHeader.qml:23
+#: ../qml/pages/Info.qml:61
-msgid "Search"
-msgstr ""
-
-#: ../qml/pages/headers/MainHeader.qml:51 ../qml/pages/settings/Settings.qml:14
-msgid "Settings"
-msgstr ""
-
-#: ../qml/pages/headers/MainHeader.qml:58 ../qml/pages/Info.qml:11
-msgid "Info"
-msgstr ""
-
-#: ../qml/pages/Info.qml:50
 msgid "<b>Version</b>"
 msgstr ""
 
-#: ../qml/pages/Info.qml:68
+#: ../qml/pages/Info.qml:82
 msgid "<b>Maintainer</>"
 msgstr ""
 
-#: ../qml/pages/Info.qml:90
+#: ../qml/pages/Info.qml:109
 msgid "Suggest improvement(s) or report a bug(s)"
 msgstr ""
 
-#: ../qml/pages/Info.qml:94
+#: ../qml/pages/Info.qml:114
 msgid "Access to the source code"
 msgstr ""
 
-#: ../qml/pages/Info.qml:101
+#: ../qml/pages/Info.qml:122
 msgid "Released under the terms of the GNU GPL v3"
 msgstr ""
 
-#: ../qml/pages/PasswordList.qml:23
+#: ../qml/pages/Info.qml:131 ../qml/pages/headers/MainHeader.qml:33
+msgid "Info"
+msgstr ""
+
+#: ../qml/pages/PasswordList.qml:37
+msgid ""
+"No password found<br>You can import a password store by cloning or importing "
+"a zip in the settings"
+msgstr ""
+
+#: ../qml/pages/PasswordList.qml:71 ../qml/pages/settings/InfoKeys.qml:169
+msgid "Decryption failed !"
+msgstr ""
+
+#: ../qml/pages/PasswordList.qml:85
 msgid "Back"
 msgstr ""
 
-#: ../qml/pages/PasswordList.qml:43
+#: ../qml/pages/PasswordList.qml:92 ../qml/pages/headers/MainHeader.qml:9
+#: ../qml/pages/headers/StackHeader.qml:9 UTPass.desktop.in.h:1
+msgid "UTPass"
+msgstr ""
+
+#: ../qml/pages/headers/MainHeader.qml:26 ../qml/pages/settings/Settings.qml:70
+msgid "Settings"
+msgstr ""
+
+#: ../qml/pages/headers/MainHeader.qml:57
+msgid "Search"
+msgstr ""
+
+#: ../qml/pages/settings/ImportGitClone.qml:36
+msgid "Repo Url"
+msgstr ""
+
+#: ../qml/pages/settings/ImportGitClone.qml:53
+msgid "Password"
+msgstr ""
+
+#: ../qml/pages/settings/ImportGitClone.qml:70
+msgid "Clone"
+msgstr ""
+
+#: ../qml/pages/settings/ImportGitClone.qml:90
 msgid ""
-"No password found<br>You can import a password store zip in the settings"
+"Importing a git repo will delete<br>any existing password store!"
+"<br>Continue ?"
 msgstr ""
 
-#: ../qml/pages/settings/ImportKeyFile.qml:17
+#: ../qml/pages/settings/ImportGitClone.qml:91
-msgid "GPG Key Import"
+#: ../qml/pages/settings/ImportZip.qml:62
+#: ../qml/pages/settings/InfoKeys.qml:131
+msgid "Yes"
 msgstr ""
 
-#: ../qml/pages/settings/ImportKeyFile.qml:69
+#: ../qml/pages/settings/ImportGitClone.qml:104
+msgid "An error occured during git clone !"
+msgstr ""
+
+#: ../qml/pages/settings/ImportGitClone.qml:113
+#: ../qml/pages/settings/ImportZip.qml:84
+msgid "Password store sucessfully imported !"
+msgstr ""
+
+#: ../qml/pages/settings/ImportGitClone.qml:125
+msgid "Git Clone Import"
+msgstr ""
+
+#: ../qml/pages/settings/ImportKeyFile.qml:57
 msgid "Key import failed !"
 msgstr ""
 
-#: ../qml/pages/settings/ImportKeyFile.qml:76
+#: ../qml/pages/settings/ImportKeyFile.qml:66
 msgid "Key successfully imported !"
 msgstr ""
 
-#: ../qml/pages/settings/ImportZip.qml:17
+#: ../qml/pages/settings/ImportKeyFile.qml:77
-msgid "Zip Password Store Import"
+msgid "GPG Key Import"
 msgstr ""
 
-#: ../qml/pages/settings/ImportZip.qml:72
+#: ../qml/pages/settings/ImportZip.qml:61
 msgid ""
 "Importing a new zip will delete<br>any existing password store!<br>Continue ?"
 msgstr ""
 
-#: ../qml/pages/settings/ImportZip.qml:82
+#: ../qml/pages/settings/ImportZip.qml:75
 msgid "Password store import failed !"
 msgstr ""
 
-#: ../qml/pages/settings/ImportZip.qml:89
+#: ../qml/pages/settings/ImportZip.qml:96
-msgid "Password store sucessfully imported !"
+msgid "Zip Password Store Import"
 msgstr ""
 
-#: ../qml/pages/settings/InfoKeys.qml:16
+#: ../qml/pages/settings/InfoKeys.qml:48
-msgid "Info Keys"
+msgid "Key ID :"
 msgstr ""
 
-#: ../qml/pages/settings/InfoKeys.qml:44
+#: ../qml/pages/settings/InfoKeys.qml:82
-msgid "Key id : %1"
+msgid "Users IDs : "
 msgstr ""
 
-#: ../qml/pages/settings/InfoKeys.qml:49
+#: ../qml/pages/settings/InfoKeys.qml:108
 msgid "Delete this key"
 msgstr ""
 
-#: ../qml/pages/settings/InfoKeys.qml:68
+#: ../qml/pages/settings/InfoKeys.qml:130
 msgid "You're are about to delete<br>%1<br>Continue ?"
 msgstr ""
 
-#: ../qml/pages/settings/InfoKeys.qml:71
+#: ../qml/pages/settings/InfoKeys.qml:148
-msgid "%1<br>will be definitively removed.<br>Continue ?"
-msgstr ""
-
-#: ../qml/pages/settings/InfoKeys.qml:87
 msgid "Key removal failed !"
 msgstr ""
 
-#: ../qml/pages/settings/InfoKeys.qml:94
+#: ../qml/pages/settings/InfoKeys.qml:157
 msgid "Key successfully deleted !"
 msgstr ""
 
-#: ../qml/pages/settings/Settings.qml:28
+#: ../qml/pages/settings/InfoKeys.qml:177
+msgid "Info Keys"
+msgstr ""
+
+#: ../qml/pages/settings/Settings.qml:23
 msgid "GPG"
 msgstr ""
 
-#: ../qml/pages/settings/Settings.qml:32
+#: ../qml/pages/settings/Settings.qml:29
 msgid "Import a GPG key file"
 msgstr ""
 
-#: ../qml/pages/settings/Settings.qml:36
+#: ../qml/pages/settings/Settings.qml:34
 msgid "Show GPG keys"
 msgstr ""
 
-#: ../qml/pages/settings/Settings.qml:43
+#: ../qml/pages/settings/Settings.qml:42
 msgid "Password Store"
 msgstr ""
 
-#: ../qml/pages/settings/Settings.qml:47
+#: ../qml/pages/settings/Settings.qml:48
+msgid "Import a Password Store using Git"
+msgstr ""
+
+#: ../qml/pages/settings/Settings.qml:53
 msgid "Import a Password Store Zip"
 msgstr ""
 
-#: ../qml/pages/settings/Settings.qml:56
+#: ../qml/pages/settings/Settings.qml:62
 msgid "Warning: importing delete any exiting Password Store"
 msgstr ""

qml/Main.qml

@@ -1,50 +1,52 @@
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
+import Pass 1.0
 import QtQuick 2.4
 import QtQuick.Layouts 1.1
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
-import Pass 1.0
 import "dialogs"
 
 MainView {
+    //theme.name: "Lomiri.Components.Themes.SuruDark"
+
     id: root
-    objectName: "mainView"
-    applicationName: "utpass.qrouland"
-
-    automaticOrientation: false
-
-    width: units.gu(48)
-    height: units.gu(80)
-
-    signal responsePassphraseDialog(bool canceled, string passphrase)
 
     function initPass(rootView) {
-        Pass.init(rootView)
+        Pass.initialize(rootView);
+        pageStack.push(Qt.resolvedUrl("pages/PasswordList.qml"));
     }
 
     function callPassphraseDialog(useridHint, description, previousWasBad) {
         //TODO use parameters to impove passphrase dialog
-        var passphraseDialog = PopupUtils.open(
+        var pop = PopupUtils.open(passphraseDialog);
-                    Qt.resolvedUrl("dialogs/PassphraseDialog.qml"))
+        pop.activateFocus();
-        passphraseDialog.activateFocus()
-
-        var validated = function (passphrase) {
-            responsePassphraseDialog(false, passphrase)
-        }
-
-        var canceled = function () {
-            responsePassphraseDialog(true, "")
-        }
-
-        passphraseDialog.validated.connect(validated)
-        passphraseDialog.canceled.connect(canceled)
     }
 
+    objectName: "mainView"
+    applicationName: "utpass.qrouland"
+    automaticOrientation: true
+    width: units.gu(45)
+    height: units.gu(75)
+
     PageStack {
         id: pageStack
-        anchors.fill: parent
 
-        Component.onCompleted: {
+        anchors.fill: parent
-            pageStack.push(Qt.resolvedUrl("pages/PasswordList.qml"))
-        }
     }
+
+    Component {
+        id: passphraseDialog
+
+        PassphraseDialog {
+            onValidated: {
+                console.info("valided");
+                Pass.responsePassphraseDialog(false, passphrase);
+            }
+            onCanceled: {
+                console.info("canceled");
+                Pass.responsePassphraseDialog(true, "");
+            }
+        }
+
+    }
+
 }

qml/components/CopyText.qml

@@ -1,18 +1,18 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
 import "../styles"
+import Lomiri.Components 1.3
+import QtQuick 2.4
 
 Item {
     id: copyText
-    property string text
 
+    property string text
     property bool commonBorder: true
     property int lBorderwidth: 0
     property int rBorderwidth: 0
     property int tBorderwidth: 0
     property int bBorderwidth: 0
     property int commonBorderWidth: 0
-    property string borderColor: UbuntuColors.warmGrey
+    property string borderColor: LomiriColors.warmGrey
 
     width: parent.width
     height: units.gu(6)
@@ -33,26 +33,27 @@ Item {
             anchors.rightMargin: units.gu(2)
             height: units.gu(4)
             name: "edit-copy"
-            color: UbuntuColors.orange
+            color: LomiriColors.orange
         }
 
         MouseArea {
             anchors.fill: parent
             onPressed: {
-                parent.color = UbuntuColors.warmGrey
+                parent.color = LomiriColors.warmGrey;
             }
             onClicked: {
-                var mimeData = Clipboard.newData()
+                var mimeData = Clipboard.newData();
-                mimeData.text = copyText.text
+                mimeData.text = copyText.text;
-                Clipboard.push(mimeData)
+                Clipboard.push(mimeData);
             }
             onReleased: {
-                parent.color = theme.palette.normal.background
+                parent.color = theme.palette.normal.background;
             }
         }
 
         CustomBorder {
             id: cb
+
             commonBorder: copyText.commonBorder
             lBorderwidth: copyText.lBorderwidth
             rBorderwidth: copyText.rBorderwidth
@@ -60,5 +61,7 @@ Item {
             bBorderwidth: copyText.bBorderwidth
             borderColor: copyText.borderColor
         }
+
     }
+
 }

qml/components/ExternalLink.qml

@@ -1,32 +1,33 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
 import "../styles"
+import Lomiri.Components 1.3
+import QtQuick 2.4
 
 Item {
     id: externalLink
 
     property string url
     property string text
-
     property bool commonBorder: true
     property int lBorderwidth: 0
     property int rBorderwidth: 0
     property int tBorderwidth: 0
     property int bBorderwidth: 0
     property int commonBorderWidth: 0
-    property string borderColor: UbuntuColors.warmGrey
+    property string borderColor: LomiriColors.warmGrey
 
     width: parent.width
     height: units.gu(6)
 
     Rectangle {
         anchors.fill: parent
+        color: theme.palette.normal.background
 
         Text {
             text: externalLink.text
             anchors.left: parent.left
             anchors.leftMargin: units.gu(2)
             anchors.verticalCenter: parent.verticalCenter
+            color: theme.palette.normal.backgroundText
         }
 
         Icon {
@@ -36,18 +37,19 @@ Item {
             width: units.gu(4)
             height: units.gu(4)
             name: "go-next"
-            color: UbuntuColors.orange
+            color: LomiriColors.orange
         }
 
         MouseArea {
             anchors.fill: parent
             onClicked: {
-                Qt.openUrlExternally(externalLink.url)
+                Qt.openUrlExternally(externalLink.url);
             }
         }
 
         CustomBorder {
             id: cb
+
             commonBorder: externalLink.commonBorder
             lBorderwidth: externalLink.lBorderwidth
             rBorderwidth: externalLink.rBorderwidth
@@ -55,5 +57,7 @@ Item {
             bBorderwidth: externalLink.bBorderwidth
             borderColor: externalLink.borderColor
         }
+
     }
+
 }

qml/components/FileDir.qml

@@ -1,24 +1,24 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
-import Pass 1.0
-import "../styles"
 import "../dialogs"
+import "../styles"
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
+import Lomiri.Components.Themes 1.3
+import Pass 1.0
+import QtQuick 2.4
 
 Component {
     Rectangle {
-        id: fileDir
-        property string activePasswordName
-
         anchors.right: parent.right
         anchors.left: parent.left
         height: units.gu(5)
+        color: theme.palette.normal.background
 
         Text {
             text: fileBaseName
             anchors.left: parent.left
             anchors.leftMargin: units.gu(2)
             anchors.verticalCenter: parent.verticalCenter
+            color: theme.palette.normal.backgroundText
         }
 
         Icon {
@@ -27,31 +27,20 @@ Component {
             anchors.rightMargin: units.gu(2)
             height: units.gu(4)
             name: fileIsDir ? "go-next" : "lock"
-            color: UbuntuColors.orange
+            color: LomiriColors.orange
         }
 
         MouseArea {
             anchors.fill: parent
             onClicked: {
+                var path = folderModel.folder + "/" + fileName;
                 if (fileIsDir) {
-                    folderModel.folder = folderModel.folder + "/" + fileName
+                    folderModel.folder = path;
-                    backAction.visible = true
+                    backAction.visible = true;
+                    passwordListHeader.title = fileName;
                 } else {
-                    fileDir.activePasswordName = fileBaseName
+                    console.debug("pass show %1".arg(path));
-
+                    Pass.show(path);
-                    Pass.onDecrypted.connect(function (text) {
-                        pageStack.push(Qt.resolvedUrl("../pages/Password.qml"),
-                                       {
-                                           "plainText": text,
-                                           "title": fileDir.activePasswordName
-                                       })
-                    })
-
-                    Pass.onDecryptFailed.connect(function () {
-                        PopupUtils.open(passwordPageDecryptError)
-                    })
-
-                    Pass.decrypt(folderModel.folder + "/" + fileName)
                 }
             }
         }
@@ -62,17 +51,9 @@ Component {
             rBorderwidth: 0
             tBorderwidth: 0
             bBorderwidth: 1
-            borderColor: UbuntuColors.warmGrey
+            borderColor: LomiriColors.warmGrey
         }
 
-        Component {
-            id: passwordPageDecryptError
-            ErrorDialog {
-                textError: i18n.tr("Decryption failed !")
-                onDialogClosed: {
-                    pageStack.pop()
-                }
-            }
-        }
     }
+
 }

qml/components/PageStackLink.qml

@@ -1,35 +1,35 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
 import "../styles"
+import Lomiri.Components 1.3
+import QtQuick 2.4
 
 Item {
     id: pageStackLink
 
     property string page
     property var params: {
-
     }
     property string text
-
     property bool commonBorder: true
     property int lBorderwidth: 0
     property int rBorderwidth: 0
     property int tBorderwidth: 0
     property int bBorderwidth: 0
     property int commonBorderWidth: 0
-    property string borderColor: UbuntuColors.warmGrey
+    property string borderColor: LomiriColors.warmGrey
 
     width: parent.width
     height: units.gu(6)
 
     Rectangle {
         anchors.fill: parent
+        color: theme.palette.normal.background
 
         Text {
             text: pageStackLink.text
             anchors.left: parent.left
             anchors.leftMargin: units.gu(2)
             anchors.verticalCenter: parent.verticalCenter
+            color: theme.palette.normal.backgroundText
         }
 
         Icon {
@@ -39,18 +39,19 @@ Item {
             width: units.gu(4)
             height: units.gu(4)
             name: "go-next"
-            color: UbuntuColors.orange
+            color: LomiriColors.orange
         }
 
         MouseArea {
             anchors.fill: parent
             onClicked: {
-                pageStack.push(page, params)
+                pageStack.push(page, params);
             }
         }
 
         CustomBorder {
             id: cb
+
             commonBorder: pageStackLink.commonBorder
             lBorderwidth: pageStackLink.lBorderwidth
             rBorderwidth: pageStackLink.rBorderwidth
@@ -58,5 +59,7 @@ Item {
             bBorderwidth: pageStackLink.bBorderwidth
             borderColor: pageStackLink.borderColor
         }
+
     }
+
 }

qml/dialogs/DoubleValidationDialog.qml

@@ -1,52 +0,0 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
-
-Dialog {
-    id: doubleValidationDialog
-
-    property int nb_validation: 0
-    property string text1
-    property string text2
-
-    signal doubleValidated
-    signal canceled
-
-    Text {
-        visible: nb_validation == 0
-        horizontalAlignment: Text.AlignHCenter
-        text: text1
-    }
-
-    Text {
-        visible: nb_validation == 1
-        horizontalAlignment: Text.AlignHCenter
-        text: text2
-    }
-
-    Button {
-        text: i18n.tr("Ok")
-        color: UbuntuColors.green
-
-        onClicked: {
-            if (nb_validation == 1) {
-                nb_validation = 0
-                doubleValidated()
-                PopupUtils.close(doubleValidationDialog)
-            } else {
-                nb_validation += 1
-            }
-        }
-    }
-
-    Button {
-        id: cancelButton
-        text: i18n.tr("Cancel")
-        color: UbuntuColors.red
-        onClicked: {
-            nb_validation = 0
-            canceled()
-            PopupUtils.close(doubleValidationDialog)
-        }
-    }
-}

qml/dialogs/ErrorDialog.qml

@@ -1,22 +1,23 @@
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
 import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
 
 Dialog {
-    id: dialogSuccess
+    id: dialog
 
     property string textError
 
-    signal dialogClosed
+    signal dialogClosed()
 
     title: i18n.tr("Error !")
     text: textError
+
     Button {
-        text: i18n.tr("OK")
+        text: i18n.tr("Close")
-        color: UbuntuColors.red
+        onClicked: function() {
-        onClicked: function () {
+            dialogClosed();
-            dialogClosed()
+            PopupUtils.close(dialog);
-            PopupUtils.close(dialogSuccess)
         }
     }
+
 }

qml/dialogs/PassphraseDialog.qml

@@ -1,25 +1,25 @@
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
 import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
 
 Dialog {
-    id: passphraseProvider
+    id: dialog
-    title: i18n.tr("Authentication required")
-    text: i18n.tr("Enter passphrase:")
 
     signal validated(string passphrase)
-    signal canceled
+    signal canceled()
 
     function activateFocus() {
-        passphraseField.forceActiveFocus()
+        passphraseField.forceActiveFocus();
     }
 
+    title: i18n.tr("Authentication required")
+    text: i18n.tr("Enter passphrase:")
+
     TextField {
         id: passphraseField
 
         placeholderText: i18n.tr("passphrase")
         echoMode: TextInput.Password
-
         onAccepted: okButton.clicked(text)
     }
 
@@ -27,24 +27,22 @@ Dialog {
         id: okButton
 
         text: i18n.tr("Ok")
-        color: UbuntuColors.green
+        color: theme.palette.normal.positive
-
         onClicked: {
-            validated(passphraseField.text)
+            validated(passphraseField.text);
-            passphraseField.text = ""
+            passphraseField.text = "";
-            PopupUtils.close(passphraseProvider)
+            PopupUtils.close(dialog);
         }
     }
 
     Button {
         id: cancelButton
+
         text: i18n.tr("Cancel")
-
-        color: UbuntuColors.red
-
         onClicked: {
-            canceled()
+            canceled();
-            PopupUtils.close(passphraseProvider)
+            PopupUtils.close(dialog);
         }
     }
+
 }

qml/dialogs/SimpleValidationDialog.qml

@@ -1,37 +1,41 @@
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
 import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
 
 Dialog {
-    id: doubleValidationDialog
+    id: dialog
 
     property string text
+    property string continueText: i18n.tr("Ok")
+    property color continueColor: theme.palette.normal.positive
 
-    signal validated
+    signal validated()
-    signal canceled
+    signal canceled()
 
     Text {
         horizontalAlignment: Text.AlignHCenter
-        text: doubleValidationDialog.text
+        text: dialog.text
     }
 
     Button {
-        text: i18n.tr("Ok")
+        id: continueButton
-        color: UbuntuColors.green
 
+        text: dialog.continueText
+        color: dialog.continueColor
         onClicked: {
-            validated()
+            validated();
-            PopupUtils.close(doubleValidationDialog)
+            PopupUtils.close(dialog);
         }
     }
 
     Button {
         id: cancelButton
+
         text: i18n.tr("Cancel")
-        color: UbuntuColors.red
         onClicked: {
-            canceled()
+            canceled();
-            PopupUtils.close(doubleValidationDialog)
+            PopupUtils.close(dialog);
         }
     }
+
 }

qml/dialogs/SuccessDialog.qml

@@ -1,22 +1,23 @@
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
 import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
 
 Dialog {
-    id: dialogSuccess
+    id: dialog
 
     property string textSuccess
 
-    signal dialogClosed
+    signal dialogClosed()
 
     title: i18n.tr("Success !")
     text: textSuccess
+
     Button {
         text: i18n.tr("OK")
-        color: UbuntuColors.green
+        onClicked: function() {
-        onClicked: function () {
+            dialogClosed();
-            dialogClosed()
+            PopupUtils.close(dialog);
-            PopupUtils.close(dialogSuccess)
         }
     }
+
 }

qml/pages/Info.qml

@@ -1,14 +1,19 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-import "headers"
 import "../components"
+import Lomiri.Components 1.3
+import QtQuick 2.4
+import "headers"
 
 Page {
     id: infoPage
 
-    header: StackHeader {
+    Component.onCompleted: {
-        id: infoHeader
+        var xhr = new XMLHttpRequest();
-        title: i18n.tr('Info')
+        xhr.open("GET", "../../manifest_.json", false);
+        xhr.send();
+        var mJson = JSON.parse(xhr.responseText);
+        manifestTitle.text = "<b>" + mJson.title + "</b>";
+        manifestVersion.text = mJson.version + "<br>" + mJson.framework + "@" + mJson.architecture;
+        manifestMaintener.text = mJson.maintainer;
     }
 
     Flow {
@@ -20,27 +25,33 @@ Page {
         Rectangle {
             width: parent.width
             height: units.gu(1)
+            color: theme.palette.normal.background
         }
 
         Text {
             id: manifestTitle
+
             horizontalAlignment: Text.AlignHCenter
             verticalAlignment: Text.AlignVCenter
             width: parent.width
             height: units.gu(8)
             fontSizeMode: Text.Fit
             font.pixelSize: 144
+            color: theme.palette.normal.backgroundText
         }
 
         Rectangle {
             width: parent.width
             height: units.gu(12)
+            color: theme.palette.normal.background
+
             Image {
                 source: "../../assets/logo.svg"
                 width: units.gu(12)
                 height: units.gu(12)
                 anchors.horizontalCenter: parent.horizontalCenter
             }
+
         }
 
         Text {
@@ -50,15 +61,18 @@ Page {
             text: i18n.tr("<b>Version</b>")
             fontSizeMode: Text.Fit
             font.pixelSize: 72
+            color: theme.palette.normal.backgroundText
         }
 
         Text {
             id: manifestVersion
+
             horizontalAlignment: Text.AlignHCenter
             width: parent.width
             height: units.gu(4)
             fontSizeMode: Text.Fit
             font.pixelSize: 72
+            color: theme.palette.normal.backgroundText
         }
 
         Text {
@@ -68,16 +82,20 @@ Page {
             text: i18n.tr("<b>Maintainer</>")
             fontSizeMode: Text.Fit
             font.pixelSize: 72
+            color: theme.palette.normal.backgroundText
         }
 
         Text {
             id: manifestMaintener
+
             horizontalAlignment: Text.AlignHCenter
             width: parent.width
             height: units.gu(2)
             fontSizeMode: Text.Fit
             font.pixelSize: 72
+            color: theme.palette.normal.backgroundText
         }
+
     }
 
     Flow {
@@ -85,32 +103,32 @@ Page {
         anchors.bottom: parent.bottom
         anchors.right: parent.right
         anchors.left: parent.left
+
         ExternalLink {
-            url: "https://taiga.rdrive.ovh/project/utpass/issues"
+            url: "https://github.com/QRouland/UTPass/issues"
             text: i18n.tr("Suggest improvement(s) or report a bug(s)")
         }
+
         ExternalLink {
-            url: "https://git.rdrive.ovh/QRouland/UTPass"
+            url: "https://github.com/QRouland/UTPass"
             text: i18n.tr("Access to the source code")
         }
+
         Text {
             width: parent.width
             height: units.gu(2)
             horizontalAlignment: Text.AlignHCenter
             verticalAlignment: Text.AlignVCenter
             text: i18n.tr("Released under the terms of the GNU GPL v3")
+            color: theme.palette.normal.backgroundText
         }
+
     }
 
-    Component.onCompleted: {
+    header: StackHeader {
-        var xhr = new XMLHttpRequest()
+        id: infoHeader
-        xhr.open("GET", "../../manifest_.json", false)
-        xhr.send()
 
-        var mJson = JSON.parse(xhr.responseText)
+        title: i18n.tr('Info')
-
-        manifestTitle.text = "<b>" + mJson.title + "</b>"
-        manifestVersion.text = mJson.version + "<br>" + mJson.framework + "@" + mJson.architecture
-        manifestMaintener.text = mJson.maintainer
     }
+
 }

qml/pages/Password.qml

@@ -1,6 +1,6 @@
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
 import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
 import "headers"
 
 Page {
@@ -10,38 +10,15 @@ Page {
     property string plainText
     property var objects
 
-    header: PageHeader {
+    Component.onCompleted: {
-        id: passwordPageHeader
+        var text_split = passwordPage.plainText.split('\n');
-        width: parent.width
+        var component = Qt.createComponent("../components/CopyText.qml");
-        height: units.gu(6)
+        for (var i = 0; i < text_split.length; i++) {
-        title: passwordPage.title
+            if (text_split[i]) {
-
+                var object = component.createObject(container);
-        contents: Item {
+                object.text = text_split[i];
-            height: parent.height
-            width: parent.width
-            Label {
-                id: labelTitle
-                text: passwordPage.title
-                anchors.verticalCenter: parent.verticalCenter
             }
         }
-
-        leadingActionBar.height: units.gu(4)
-        leadingActionBar.actions: [
-            Action {
-                id: backAction
-                iconName: "back"
-                text: "Back"
-                onTriggered: {
-                    passwordPage.plainText = ""
-                    for (var object in objects) {
-                        object.text = ""
-                        object.destroy()
-                    }
-                    pageStack.pop()
-                }
-            }
-        ]
     }
 
     Rectangle {
@@ -52,18 +29,49 @@ Page {
 
         Flow {
             id: container
+
             anchors.fill: parent
         }
+
     }
 
-    Component.onCompleted: {
+    header: PageHeader {
-        var text_split = passwordPage.plainText.split('\n')
+        id: passwordPageHeader
-        var component = Qt.createComponent("../components/CopyText.qml")
+
-        for (var i = 0; i < text_split.length; i++) {
+        width: parent.width
-            if (text_split[i]) {
+        height: units.gu(6)
-                var object = component.createObject(container)
+        title: passwordPage.title
-                object.text = text_split[i]
+        leadingActionBar.height: units.gu(4)
+        leadingActionBar.actions: [
+            Action {
+                id: backAction
+
+                iconName: "back"
+                text: "Back"
+                onTriggered: {
+                    passwordPage.plainText = null;
+                    for (var object in objects) {
+                        object.text = null;
+                        object.destroy();
+                    }
+                    pageStack.pop();
+                }
             }
+        ]
+
+        contents: Item {
+            height: parent.height
+            width: parent.width
+
+            Label {
+                id: labelTitle
+
+                text: passwordPage.title
+                anchors.verticalCenter: parent.verticalCenter
+            }
+
         }
+
     }
+
 }

qml/pages/PasswordList.qml

@@ -1,8 +1,10 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Qt.labs.folderlistmodel 2.1
-import Pass 1.0
 import "../components"
+import "../dialogs"
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
+import Pass 1.0
+import Qt.labs.folderlistmodel 2.1
+import QtQuick 2.4
 import "headers"
 
 Page {
@@ -11,25 +13,17 @@ Page {
     property string passwordStorePath
 
     anchors.fill: parent
-
+    Component.onCompleted: {
-    header: MainHeader {
+        passwordStorePath = "file:" + Pass.password_store;
-        id: passwordListHeader
+        Pass.onShowSucceed.connect(function(filename, text) {
-
+            pageStack.push(Qt.resolvedUrl("../pages/Password.qml"), {
-        leadingActionBar.height: units.gu(4)
+                "plainText": text,
-        leadingActionBar.actions: [
+                "title": filename
-            Action {
+            });
-                id: backAction
+        });
-                iconName: "back"
+        Pass.onShowFailed.connect(function(message) {
-                text: i18n.tr("Back")
+            PopupUtils.open(passwordPageDecryptError);
-                visible: false
+        });
-                onTriggered: {
-                    folderModel.folder = folderModel.parentFolder
-                    if (folderModel.rootFolder === folderModel.folder) {
-                        backAction.visible = false
-                    }
-                }
-            }
-        ]
     }
 
     Rectangle {
@@ -38,13 +32,14 @@ Page {
         anchors.right: parent.right
         anchors.left: parent.left
         visible: folderModel.count == 0
+
         Text {
-            text: i18n.tr(
+            text: i18n.tr("No password found<br>You can import a password store by cloning or importing a zip in the settings")
-                      "No password found<br>You can import a password store zip in the settings")
             anchors.horizontalCenter: parent.horizontalCenter
             anchors.verticalCenter: parent.verticalCenter
             horizontalAlignment: Text.AlignHCenter
         }
+
     }
 
     ListView {
@@ -56,17 +51,51 @@ Page {
 
         model: FolderListModel {
             id: folderModel
+
             nameFilters: ["*.gpg"]
             rootFolder: passwordStorePath
             folder: passwordStorePath
             showDirs: true
         }
+
         delegate: FileDir {
             id: fileDelegate
         }
+
     }
 
-    Component.onCompleted: {
+    Component {
-        passwordStorePath = "file:" + Pass.getPasswordStore()
+        id: passwordPageDecryptError
+
+        ErrorDialog {
+            textError: i18n.tr("Decryption failed !")
+        }
+
     }
+
+    header: MainHeader {
+        id: passwordListHeader
+
+        leadingActionBar.height: units.gu(4)
+        leadingActionBar.actions: [
+            Action {
+                id: backAction
+
+                iconName: "back"
+                text: i18n.tr("Back")
+                visible: false
+                onTriggered: {
+                    folderModel.folder = folderModel.parentFolder;
+                    console.debug(folderModel.folder);
+                    if (folderModel.rootFolder === folderModel.folder) {
+                        backAction.visible = false;
+                        passwordListHeader.title = i18n.tr("UTPass");
+                    } else {
+                        passwordListHeader.title = folderModel.folder;
+                    }
+                }
+            }
+        ]
+    }
+
 }

qml/pages/headers/MainHeader.qml

@@ -1,40 +1,15 @@
+import Lomiri.Components 1.3
 import QtQuick 2.4
-import Ubuntu.Components 1.3
 
 PageHeader {
     id: mainHeader
+
     width: parent.width
     height: units.gu(6)
     title: i18n.tr("UTPass")
-
-    contents: Item {
-        height: parent.height
-        width: parent.width
-        Label {
-            id: labelTitle
-            text: mainHeader.title
-            anchors.verticalCenter: parent.verticalCenter
-            visible: true
-        }
-        TextField {
-            id: searchBar
-            anchors.right: parent.right
-            anchors.left: parent.left
-            placeholderText: i18n.tr("Search")
-            height: units.gu(4)
-            visible: false
-            anchors.verticalCenter: parent.verticalCenter
-            onFocusChanged: {
-
-            }
-        }
-    }
-
     trailingActionBar.height: units.gu(4)
     trailingActionBar.numberOfSlots: 2
     trailingActionBar.actions: [
-
-
         /*Action { TODO
             iconName: "search"
             text: i18n.tr("Search")
@@ -50,15 +25,43 @@ PageHeader {
             iconName: "settings"
             text: i18n.tr("Settings")
             onTriggered: {
-                pageStack.push(Qt.resolvedUrl("../settings/Settings.qml"))
+                pageStack.push(Qt.resolvedUrl("../settings/Settings.qml"));
             }
         },
         Action {
             iconName: "info"
             text: i18n.tr("Info")
             onTriggered: {
-                pageStack.push(Qt.resolvedUrl("../Info.qml"))
+                pageStack.push(Qt.resolvedUrl("../Info.qml"));
             }
         }
     ]
+
+    contents: Item {
+        height: parent.height
+        width: parent.width
+
+        Label {
+            id: labelTitle
+
+            text: mainHeader.title
+            anchors.verticalCenter: parent.verticalCenter
+            visible: true
+        }
+
+        TextField {
+            id: searchBar
+
+            anchors.right: parent.right
+            anchors.left: parent.left
+            placeholderText: i18n.tr("Search")
+            height: units.gu(4)
+            visible: false
+            anchors.verticalCenter: parent.verticalCenter
+            onFocusChanged: {
+            }
+        }
+
+    }
+
 }

qml/pages/headers/StackHeader.qml

@@ -1,31 +1,36 @@
+import Lomiri.Components 1.3
 import QtQuick 2.4
-import Ubuntu.Components 1.3
 
 PageHeader {
     id: stackHeader
+
     width: parent.width
     height: units.gu(6)
     title: i18n.tr("UTPass")
-
-    contents: Item {
-        height: parent.height
-        width: parent.width
-        Label {
-            id: labelTitle
-            text: stackHeader.title
-            anchors.verticalCenter: parent.verticalCenter
-        }
-    }
-
     leadingActionBar.height: units.gu(4)
     leadingActionBar.actions: [
         Action {
             id: backAction
+
             iconName: "back"
             text: "Back"
             onTriggered: {
-                pageStack.pop()
+                pageStack.pop();
             }
         }
     ]
+
+    contents: Item {
+        height: parent.height
+        width: parent.width
+
+        Label {
+            id: labelTitle
+
+            text: stackHeader.title
+            anchors.verticalCenter: parent.verticalCenter
+        }
+
+    }
+
 }

qml/pages/settings/ImportGitClone.qml

@@ -0,0 +1,128 @@
+import "../../components"
+import "../../dialogs"
+import "../headers"
+import Git 1.0
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
+import Pass 1.0
+import QtQuick 2.4
+
+Page {
+    id: importGitClonePage
+
+    Component.onCompleted: {
+        PopupUtils.open(importGitCloneValidation, importGitClonePage);
+    }
+
+    Flow {
+        anchors.top: importGitCloneHeader.bottom
+        anchors.right: parent.right
+        anchors.left: parent.left
+        anchors.leftMargin: units.gu(2)
+        anchors.rightMargin: units.gu(2)
+        spacing: units.gu(1)
+
+        Rectangle {
+            width: parent.width
+            height: units.gu(1)
+        }
+
+        Text {
+            id: repoUrlLabel
+
+            horizontalAlignment: Text.AlignHCenter
+            verticalAlignment: Text.AlignVCenter
+            width: parent.width
+            text: i18n.tr('Repo Url')
+        }
+
+        TextField {
+            id: repoUrlInput
+
+            horizontalAlignment: Text.AlignHCenter
+            verticalAlignment: Text.AlignVCenter
+            width: parent.width
+        }
+
+        Text {
+            id: repoPasswordLabel
+
+            horizontalAlignment: Text.AlignHCenter
+            verticalAlignment: Text.AlignVCenter
+            width: parent.width
+            text: i18n.tr('Password')
+        }
+
+        TextField {
+            id: repoPasswordInput
+
+            horizontalAlignment: Text.AlignHCenter
+            verticalAlignment: Text.AlignVCenter
+            width: parent.width
+            echoMode: TextInput.Password
+        }
+
+        Button {
+            id: buttonAdd
+
+            width: parent.width
+            color: theme.palette.normal.positive
+            text: i18n.tr('Clone')
+            onClicked: {
+                var ret = false;
+                if (repoPasswordInput.text === "")
+                    ret = Git.clone_http(repoUrlInput.text, Pass.password_store);
+                else
+                    ret = Git.clone_http_pass(repoUrlInput.text, Pass.password_store, repoPasswordInput.text);
+                if (ret)
+                    PopupUtils.open(dialogImportGitCloneSuccess);
+                else
+                    PopupUtils.open(importGitCloneError, importGitClonePage);
+            }
+        }
+
+    }
+
+    Component {
+        id: importGitCloneValidation
+
+        SimpleValidationDialog {
+            text: i18n.tr("Importing a git repo will delete<br>any existing password store!<br>Continue ?")
+            continueText: i18n.tr("Yes")
+            continueColor: theme.palette.normal.negative
+            onCanceled: {
+                pageStack.pop();
+            }
+        }
+
+    }
+
+    Component {
+        id: importGitCloneError
+
+        ErrorDialog {
+            textError: i18n.tr("An error occured during git clone !")
+        }
+
+    }
+
+    Component {
+        id: dialogImportGitCloneSuccess
+
+        SuccessDialog {
+            textSuccess: i18n.tr("Password store sucessfully imported !")
+            onDialogClosed: {
+                pageStack.pop();
+                pageStack.pop();
+            }
+        }
+
+    }
+
+    header: StackHeader {
+        id: importGitCloneHeader
+
+        title: i18n.tr('Git Clone Import')
+    }
+
+}

qml/pages/settings/ImportKeyFile.qml

@@ -1,82 +1,80 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Content 1.3
-import Ubuntu.Components.Popups 1.3
-import Pass 1.0
-import Utils 1.0
-import "../headers"
 import "../../dialogs"
+import "../headers"
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
+import Lomiri.Content 1.3
+import Pass 1.0
+import QtQuick 2.4
+import Utils 1.0
 
 Page {
     id: importKeyFilePage
 
     property var activeTransfer
 
-    header: StackHeader {
-        id: importKeyHeader
-        title: i18n.tr("GPG Key Import")
-    }
-
     ContentPeerPicker {
         anchors.top: importKeyHeader.bottom
         anchors.bottom: parent.bottom
         anchors.topMargin: importKeyFilePage.header.height
-
         width: parent.width
-
         visible: parent.visible
         showTitle: false
         contentType: ContentType.Text
         handler: ContentHandler.Source
-
         onPeerSelected: {
-            peer.selectionType = ContentTransfer.Single
+            peer.selectionType = ContentTransfer.Single;
-            importKeyFilePage.activeTransfer = peer.request()
+            importKeyFilePage.activeTransfer = peer.request();
-
+            importKeyFilePage.activeTransfer.stateChanged.connect(function() {
-            importKeyFilePage.activeTransfer.stateChanged.connect(function () {
                 if (importKeyFilePage.activeTransfer.state === ContentTransfer.Charged) {
-                    console.log("Charged")
+                    console.log("Charged");
-                    console.log(importKeyFilePage.activeTransfer.items[0].url)
+                    console.log(importKeyFilePage.activeTransfer.items[0].url);
-
+                    var status = Pass.importGPGKey(importKeyFilePage.activeTransfer.items[0].url);
-                    var status = Pass.gpgImportKeyFromFile(
+                    Utils.rmFile(importKeyFilePage.activeTransfer.items[0].url);
-                                importKeyFilePage.activeTransfer.items[0].url)
+                    if (status)
-
+                        PopupUtils.open(dialogImportKeyPageSucess);
-                    Utils.rmFile(importKeyFilePage.activeTransfer.items[0].url)
+                    else
-                    if (status) {
+                        PopupUtils.open(dialogImportKeyPageError);
-                        PopupUtils.open(dialogImportKeyPageSucess)
+                    importKeyFilePage.activeTransfer = null;
-                    } else {
-                        PopupUtils.open(dialogImportKeyPageError)
-                    }
-                    importKeyFilePage.activeTransfer = null
                 }
-            })
+            });
         }
-
         onCancelPressed: {
-            pageStack.pop()
+            pageStack.pop();
         }
     }
 
     ContentTransferHint {
         id: transferHint
+
         anchors.fill: parent
         activeTransfer: importKeyFilePage.activeTransfer
     }
 
     Component {
         id: dialogImportKeyPageError
+
         ErrorDialog {
             textError: i18n.tr("Key import failed !")
         }
+
     }
 
     Component {
         id: dialogImportKeyPageSucess
+
         SuccessDialog {
             textSuccess: i18n.tr("Key successfully imported !")
             onDialogClosed: {
-                pageStack.pop()
+                pageStack.pop();
             }
         }
+
     }
+
+    header: StackHeader {
+        id: importKeyHeader
+
+        title: i18n.tr("GPG Key Import")
+    }
+
 }

qml/pages/settings/ImportZip.qml

@@ -1,99 +1,99 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Content 1.3
-import Ubuntu.Components.Popups 1.3
-import Pass 1.0
-import Utils 1.0
-import "../headers"
 import "../../dialogs"
+import "../headers"
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
+import Lomiri.Content 1.3
+import Pass 1.0
+import QtQuick 2.4
+import Utils 1.0
 
 Page {
     id: importZipPage
 
     property var activeTransfer
 
-    header: StackHeader {
+    Component.onCompleted: {
-        id: importZipHeader
+        PopupUtils.open(importZipPageImportValidation, importZipPage);
-        title: i18n.tr("Zip Password Store Import")
     }
 
     ContentPeerPicker {
         anchors.top: importZipHeader.bottom
         anchors.bottom: parent.bottom
         anchors.topMargin: importZipPage.header.height
-
         width: parent.width
-
         visible: parent.visible
         showTitle: false
         contentType: ContentType.Text
         handler: ContentHandler.Source
-
         onPeerSelected: {
-            peer.selectionType = ContentTransfer.Single
+            peer.selectionType = ContentTransfer.Single;
-            importZipPage.activeTransfer = peer.request()
+            importZipPage.activeTransfer = peer.request();
-
+            importZipPage.activeTransfer.stateChanged.connect(function() {
-            importZipPage.activeTransfer.stateChanged.connect(function () {
                 if (importZipPage.activeTransfer.state === ContentTransfer.Charged) {
-                    console.log("Charged")
+                    console.log("Charged");
-                    console.log(importZipPage.activeTransfer.items[0].url)
+                    console.log(importZipPage.activeTransfer.items[0].url);
-
+                    var status = Utils.unzip(importZipPage.activeTransfer.items[0].url, Pass.getPasswordStore());
-                    var status = Utils.unzip(
+                    Utils.rmFile(importZipPage.activeTransfer.items[0].url);
-                                importZipPage.activeTransfer.items[0].url,
+                    if (status)
-                                Pass.getPasswordStore())
+                        PopupUtils.open(dialogImportZipPageSuccess);
-
+                    else
-                    Utils.rmFile(importZipPage.activeTransfer.items[0].url)
+                        PopupUtils.open(dialogImportZipPageError);
-
+                    importZipPage.activeTransfer = null;
-                    if (status) {
-                        PopupUtils.open(dialogImportZipPageSuccess)
-                    } else {
-                        PopupUtils.open(dialogImportZipPageError)
-                    }
-                    importZipPage.activeTransfer = null
                 }
-            })
+            });
         }
-
         onCancelPressed: {
-            pageStack.pop()
+            pageStack.pop();
         }
     }
 
     ContentTransferHint {
         id: transferHint
+
         anchors.fill: parent
         activeTransfer: importZipPage.activeTransfer
     }
 
     Component {
         id: importZipPageImportValidation
+
         SimpleValidationDialog {
-            text: i18n.tr(
+            text: i18n.tr("Importing a new zip will delete<br>any existing password store!<br>Continue ?")
-                      "Importing a new zip will delete<br>any existing password store!<br>Continue ?")
+            continueText: i18n.tr("Yes")
+            continueColor: theme.palette.normal.negative
             onCanceled: {
-                pageStack.pop()
+                pageStack.pop();
             }
         }
+
     }
 
     Component {
         id: dialogImportZipPageError
+
         ErrorDialog {
             textError: i18n.tr("Password store import failed !")
         }
+
     }
 
     Component {
         id: dialogImportZipPageSuccess
+
         SuccessDialog {
             textSuccess: i18n.tr("Password store sucessfully imported !")
             onDialogClosed: {
-                pageStack.pop()
+                pageStack.pop();
+                pageStack.pop();
             }
         }
+
     }
 
-    Component.onCompleted: {
+    header: StackHeader {
-        PopupUtils.open(importZipPageImportValidation, importZipPage)
+        id: importZipHeader
+
+        title: i18n.tr("Zip Password Store Import")
     }
+
 }

qml/pages/settings/InfoKeys.qml

@@ -1,30 +1,34 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Ubuntu.Components.Popups 1.3
-import Pass 1.0
-import "../headers"
 import "../../components"
 import "../../dialogs"
+import "../headers"
+import Lomiri.Components 1.3
+import Lomiri.Components.Popups 1.3
+import Pass 1.0
+import QtQuick 2.4
 
 Page {
     id: infoKeysPage
 
     property string currentKey
 
-    header: StackHeader {
+    Component.onCompleted: {
-        id: infoKeysHeader
+        Pass.onGetAllGPGKeysSucceed.connect(function(keys_info) {
-        title: i18n.tr('Info Keys')
+            infoKeysListView.model = keys_info;
+        });
+        Pass.getAllGPGKeysFailed.connect(function(message) {
+            PopupUtils.open(infoKeysPageGetAllError);
+        });
+        Pass.getAllGPGKeys();
     }
 
     ListView {
         id: infoKeysListView
+
         anchors.top: infoKeysHeader.bottom
         anchors.bottom: parent.bottom
         anchors.right: parent.right
         anchors.left: parent.left
 
-        model: Pass.gpgGetAllKeysModel()
-
         delegate: Grid {
             columns: 1
             width: parent.width
@@ -34,67 +38,143 @@ Page {
             Rectangle {
                 width: parent.width
                 height: units.gu(1)
+                color: theme.palette.normal.background
             }
 
             Text {
-                id: uidKey
                 width: parent.width
                 horizontalAlignment: Text.AlignHCenter
                 verticalAlignment: Text.AlignVCenter
-                text: i18n.tr('Key id : %1').arg(model.modelData.uid)
+                text: i18n.tr('Key ID :')
+                color: theme.palette.normal.backgroundText
+            }
+
+            Text {
+                width: parent.width
+                horizontalAlignment: Text.AlignHCenter
+                verticalAlignment: Text.AlignVCenter
+                text: model.modelData.uid
+                color: theme.palette.normal.backgroundText
+            }
+
+            Rectangle {
+                width: parent.width
+                height: units.gu(1)
+                color: theme.palette.normal.background
+            }
+
+            ListModel {
+                id: userIdsModel
+
+                Component.onCompleted: {
+                    for (var i = 0; i < model.modelData.userIds.length; ++i) {
+                        userIdsModel.append({
+                            "model": model.modelData.userIds[i]
+                        });
+                    }
+                }
+            }
+
+            Text {
+                width: parent.width
+                horizontalAlignment: Text.AlignHCenter
+                verticalAlignment: Text.AlignVCenter
+                text: i18n.tr('Users IDs : ')
+                color: theme.palette.normal.backgroundText
+            }
+
+            Repeater {
+                model: userIdsModel
+
+                Text {
+                    width: parent.width
+                    horizontalAlignment: Text.AlignHCenter
+                    verticalAlignment: Text.AlignVCenter
+                    text: modelData.uid
+                    color: theme.palette.normal.backgroundText
+                }
+
+            }
+
+            Rectangle {
+                width: parent.width
+                height: units.gu(1)
+                color: theme.palette.normal.background
             }
 
             Button {
                 id: buttonDeleteKey
+
                 text: i18n.tr("Delete this key")
-                color: UbuntuColors.red
+                color: theme.palette.normal.negative
                 onClicked: {
-                    infoKeysPage.currentKey = model.modelData.uid
+                    infoKeysPage.currentKey = model.modelData.uid;
-                    PopupUtils.open(infoKeysPageDeleteValidation, infoKeysPage)
+                    PopupUtils.open(infoKeysPageDeleteValidation, infoKeysPage);
                 }
             }
 
             Rectangle {
                 width: parent.width
                 height: units.gu(1)
+                color: theme.palette.normal.background
             }
+
         }
+
     }
 
     Component {
         id: infoKeysPageDeleteValidation
-        DoubleValidationDialog {
+
-            text1: i18n.tr(
+        SimpleValidationDialog {
-                       "You're are about to delete<br>%1<br>Continue ?").arg(
+            text: i18n.tr("You're are about to delete<br>%1<br>Continue ?").arg(infoKeysPage.currentKey)
-                       infoKeysPage.currentKey)
+            continueText: i18n.tr("Yes")
-            text2: i18n.tr(
+            continueColor: theme.palette.normal.negative
-                       "%1<br>will be definitively removed.<br>Continue ?").arg(
+            onValidated: {
-                       infoKeysPage.currentKey)
+                var status = Pass.deleteGPGKey(infoKeysPage.currentKey);
-            onDoubleValidated: {
+                if (status)
-                var status = Pass.gpgDeleteKeyId(infoKeysPage.currentKey)
+                    PopupUtils.open(infoKeysPageDeleteSuccess);
-                if (status) {
+                else
-                    PopupUtils.open(infoKeysPageDeleteSuccess)
+                    PopupUtils.open(infoKeysPageDeleteError);
-                } else {
-                    PopupUtils.open(infoKeysPageDeleteError)
-                }
             }
         }
+
     }
 
     Component {
         id: infoKeysPageDeleteError
+
         ErrorDialog {
             textError: i18n.tr("Key removal failed !")
         }
+
     }
 
     Component {
         id: infoKeysPageDeleteSuccess
+
         SuccessDialog {
             textSuccess: i18n.tr("Key successfully deleted !")
             onDialogClosed: {
-                infoKeysListView.model = Pass.gpgGetAllKeysModel()
+                infoKeysListView.model = Pass.getAllGPGKeys();
             }
         }
+
     }
+
+    Component {
+        id: infoKeysPageGetAllError
+
+        ErrorDialog {
+            textError: i18n.tr("Decryption failed !")
+        }
+
+    }
+
+    header: StackHeader {
+        id: infoKeysHeader
+
+        title: i18n.tr('Info Keys')
+    }
+
 }

qml/pages/settings/Settings.qml

@@ -1,19 +1,14 @@
-import QtQuick 2.4
-import Ubuntu.Components 1.3
-import Pass 1.0
-import "../headers"
 import "../../components"
+import "../headers"
+import Lomiri.Components 1.3
+import Pass 1.0
+import QtQuick 2.4
 
 Page {
     id: settingsPage
 
     property string gpgKeyId: ""
 
-    header: StackHeader {
-        id: settingsHeader
-        title: i18n.tr('Settings')
-    }
-
     Flow {
         anchors.top: settingsHeader.bottom
         anchors.bottom: parent.bottom
@@ -26,34 +21,53 @@ Page {
             width: parent.width
             height: units.gu(4)
             text: i18n.tr('GPG')
+            color: theme.palette.normal.backgroundText
         }
+
         PageStackLink {
             page: Qt.resolvedUrl("ImportKeyFile.qml")
             text: i18n.tr('Import a GPG key file')
         }
+
         PageStackLink {
             page: Qt.resolvedUrl("InfoKeys.qml")
             text: i18n.tr('Show GPG keys')
         }
+
         Text {
             horizontalAlignment: Text.AlignHCenter
             verticalAlignment: Text.AlignVCenter
             width: parent.width
             height: units.gu(4)
             text: i18n.tr('Password Store')
+            color: theme.palette.normal.backgroundText
         }
+
+        PageStackLink {
+            page: Qt.resolvedUrl("ImportGitClone.qml")
+            text: i18n.tr('Import a Password Store using Git')
+        }
+
         PageStackLink {
             page: Qt.resolvedUrl("ImportZip.qml")
             text: i18n.tr('Import a Password Store Zip')
         }
+
         Text {
             horizontalAlignment: Text.AlignHCenter
             verticalAlignment: Text.AlignVCenter
             width: parent.width
             height: units.gu(4)
-            color: UbuntuColors.red
+            color: LomiriColors.red
-            text: i18n.tr(
+            text: i18n.tr('Warning: importing delete any exiting Password Store')
-                      'Warning: importing delete any exiting Password Store')
         }
+
     }
+
+    header: StackHeader {
+        id: settingsHeader
+
+        title: i18n.tr('Settings')
+    }
+
 }

qml/styles/CustomBorder.qml

@@ -4,18 +4,14 @@ import QtQuick 2.4
 
 Rectangle {
     property bool commonBorder: true
-
     property int lBorderwidth: 1
     property int rBorderwidth: 1
     property int tBorderwidth: 1
     property int bBorderwidth: 1
-
     property int commonBorderWidth: 1
-
-    z: -1
-
     property string borderColor: "white"
 
+    z: -1
     color: borderColor
 
     anchors {
@@ -23,10 +19,10 @@ Rectangle {
         right: parent.right
         top: parent.top
         bottom: parent.bottom
-
         topMargin: commonBorder ? -commonBorderWidth : -tBorderwidth
         bottomMargin: commonBorder ? -commonBorderWidth : -bBorderwidth
         leftMargin: commonBorder ? -commonBorderWidth : -lBorderwidth
         rightMargin: commonBorder ? -commonBorderWidth : -rBorderwidth
     }
+
 }

tests/assets/gpg/passphrase.txt

@@ -0,0 +1 @@
+utpasspassphrase

tests/assets/password-store/.gitattributes

@@ -0,0 +1 @@
+*.gpg diff=gpg

tests/assets/password-store/.gpg-id

@@ -0,0 +1 @@
+UTPass Test

tests/assets/password-store/test.gpg

@@ -0,0 +1 @@
+<EFBFBD>^<03><><EFBFBD><EFBFBD><16>8m
@%f#<23><><EFBFBD>¹<EFBFBD><C2B9><1F>nW<6E>[q<><71><EFBFBD>X<12>&<26>>&MO`0<><30>@

tests/plugins/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(TestsUtils)

tests/plugins/TestsUtils/CMakeLists.txt

@@ -0,0 +1,29 @@
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
+set(PLUGIN "TestsUtils")
+
+set(
+        SRC
+        plugin.cpp
+        utils.cpp
+)
+
+set(CMAKE_AUTOMOC ON)
+
+execute_process(
+        COMMAND dpkg-architecture -qDEB_HOST_MULTIARCH
+        OUTPUT_VARIABLE ARCH_TRIPLET
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+)
+
+if(ARCH_TRIPLET STREQUAL "")
+    set(ARCH_TRIPLET x86_64-linux-gnu)
+endif()
+
+add_library(${PLUGIN} MODULE ${SRC})
+set_target_properties(${PLUGIN} PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PLUGIN})
+qt5_use_modules(${PLUGIN} Qml Quick DBus)
+
+set(QT_IMPORTS_DIR "/lib/${ARCH_TRIPLET}")
+
+install(TARGETS ${PLUGIN} DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN}/)
+install(FILES qmldir DESTINATION ${QT_IMPORTS_DIR}/${PLUGIN}/)

tests/plugins/TestsUtils/plugin.cpp

@@ -0,0 +1,10 @@
+#include <QtQml>
+
+#include "plugin.h"
+#include "utils.h"
+
+void TestsUtilsPlugin::registerTypes(const char *uri)
+{
+    //@uri TestUtils
+    qmlRegisterSingletonType<TestsUtilsPlugin>(uri, 1, 0, "TestUtils", [](QQmlEngine *, QJSEngine *) -> QObject * { return new TestsUtils; });
+}

tests/plugins/TestsUtils/plugin.h

@@ -0,0 +1,16 @@
+#ifndef TESTSUTILSPLUGIN_H
+#define TESTSUTILSPLUGIN_H
+
+#include <QQmlExtensionPlugin>
+
+class TestsUtilsPlugin : public QQmlExtensionPlugin
+{
+    Q_OBJECT
+    Q_PLUGIN_METADATA(IID
+                      "org.qt-project.Qt.QQmlExtensionInterface")
+
+public:
+    void registerTypes(const char *uri) override;
+};
+
+#endif

tests/plugins/TestsUtils/qmldir

@@ -0,0 +1,2 @@
+module TestUtils
+plugin TestUtils

tests/plugins/TestsUtils/utils.cpp

@@ -0,0 +1,38 @@
+#include <QFile>
+#include <QDir>
+#include <QUrl>
+#include <QUuid>
+#include <QtCore/QStandardPaths>
+#include <quazip5/JlCompress.h>
+
+#include "utils.h"
+
+
+QString TestsUtils::getTempPath()
+{
+    qFatal("yp");
+    // Get the system's temporary directory
+    QString tempDir = QStandardPaths::writableLocation(QStandardPaths::CacheLocation);
+    qDebug() << "TempDir : " << tempDir;
+
+    // Generate a unique UUID
+    QString uuid = QUuid::createUuid().toString(QUuid::WithoutBraces);
+
+    // Create a new directory using the generated UUID
+    QString newTempDir = tempDir + "/" + uuid;
+
+    QDir dir;
+    if (!dir.exists(newTempDir)) {
+        // Create the directory
+        if (dir.mkpath(newTempDir)) {
+            return newTempDir;  // Return the path if successful
+        } else {
+            return "Failed to create directory";  // Return an error message
+        }
+    } else {
+        return newTempDir;  // If the directory already exists, return its path
+    }
+}
+
+
+

tests/plugins/TestsUtils/utils.h

@@ -0,0 +1,19 @@
+#ifndef TESTSUTILS_H
+#define TESTSUTILS_H
+
+#include <QObject>
+#include <QUrl>
+#include <QQuickWindow>
+
+class TestsUtils : public QObject
+{
+    Q_OBJECT
+
+public:
+    TestsUtils() = default;
+    ~TestsUtils() override = default;
+
+    Q_INVOKABLE QString getTempPath();
+};
+
+#endif

tests/unit/tst_git.qml

@@ -0,0 +1,11 @@
+import Git 1.0
+import QtQuick 2.9
+import QtTest 1.2
+
+TestCase {
+    function test_git_clone() {
+        verify(Git.clone("", ""));
+    }
+
+    name: "git"
+}

tests/unit/tst_pass.qml

@@ -0,0 +1,11 @@
+import Git 1.0
+import QtQuick 2.9
+import QtTest 1.2
+
+TestCase {
+    function test_git_clone() {
+        verify(Git.clone("", ""));
+    }
+
+    name: "git"
+}

tests/unit/tst_utils.qml

@@ -0,0 +1,15 @@
+import QtQuick 2.9
+import QtTest 1.2
+import TestUtils 1.0
+import Utils 1.0
+
+TestCase {
+    function test_unzip() {
+        var tempPath = TestUtils.getTempPath() + "/password-store";
+        var zipUrl = Qt.resolvedUrl("../assets/archive.zip");
+        var r = Utils.unzip(zipUrl, tempPath);
+        verify(r, "Unzip return an error %1".arg(zipUrl));
+    }
+
+    name: "utils"
+}