初步实现功能
This commit is contained in:
shell committed
1 parent
f23c6a3fbb
commit
f0b6efb126
15 files changed
+783
-708
No files matched your search
+439
-300
@@ -1,300 +1,439 @@
|
||||
#include "seafile/fs/seafile_store.hpp"
|
||||
|
||||
#include <sqlite_orm/sqlite_orm.h>
|
||||
#include <string>
|
||||
|
||||
#include "seafile/api/account_info.hpp"
|
||||
#include "seafile/api/repo_info.hpp"
|
||||
#include "seafile/fs/storage/repo_entry.hpp"
|
||||
#include <stack>
|
||||
#include "util/application_path.hpp"
|
||||
|
||||
//
|
||||
// Created by Shell on 2026/7/16.
|
||||
//
|
||||
namespace seafile::fs
|
||||
{
|
||||
using RepoEntry = storage::RepoEntry;
|
||||
using AccountInfo = api::AccountInfo;
|
||||
using RepoInfo = api::RepoInfo;
|
||||
|
||||
namespace
|
||||
{
|
||||
auto make_storage(const std::string& path)
|
||||
{
|
||||
// clang-format off
|
||||
return sqlite_orm::make_storage(path,
|
||||
sqlite_orm::make_table("account_info",
|
||||
sqlite_orm::make_column("space_usage", &AccountInfo::space_usage),
|
||||
sqlite_orm::make_column("avatar_url", &AccountInfo::avatar_url),
|
||||
sqlite_orm::make_column("email", &AccountInfo::email, sqlite_orm::primary_key()),
|
||||
sqlite_orm::make_column("name", &AccountInfo::name),
|
||||
sqlite_orm::make_column("total", &AccountInfo::total),
|
||||
sqlite_orm::make_column("usage", &AccountInfo::usage),
|
||||
sqlite_orm::make_column("login_id", &AccountInfo::login_id),
|
||||
sqlite_orm::make_column("department", &AccountInfo::department),
|
||||
sqlite_orm::make_column("contact_email", &AccountInfo::contact_email),
|
||||
sqlite_orm::make_column("institution", &AccountInfo::institution),
|
||||
sqlite_orm::make_column("is_staff", &AccountInfo::is_staff),
|
||||
sqlite_orm::make_column("file_updates_email_interval", &AccountInfo::file_updates_email_interval),
|
||||
sqlite_orm::make_column("collaborate_email_interval",&AccountInfo::collaborate_email_interval)
|
||||
),
|
||||
sqlite_orm::make_table("repo_info",
|
||||
sqlite_orm::make_column("type",&RepoInfo::type),
|
||||
sqlite_orm::make_column("id",&RepoInfo::id, sqlite_orm::primary_key()),
|
||||
sqlite_orm::make_column("owner",&RepoInfo::owner),
|
||||
sqlite_orm::make_column("name",&RepoInfo::name),
|
||||
sqlite_orm::make_column("mtime",&RepoInfo::mtime),
|
||||
sqlite_orm::make_column("size",&RepoInfo::size),
|
||||
sqlite_orm::make_column("encrypted",&RepoInfo::encrypted),
|
||||
sqlite_orm::make_column("root",&RepoInfo::root),
|
||||
sqlite_orm::make_column("permission",&RepoInfo::permission),
|
||||
sqlite_orm::make_column("modifier_email",&RepoInfo::modifier_email),
|
||||
sqlite_orm::make_column("modifier_contact_email",&RepoInfo::modifier_contact_email),
|
||||
sqlite_orm::make_column("modifier_name",&RepoInfo::modifier_name),
|
||||
sqlite_orm::make_column("file_count",&RepoInfo::file_count),
|
||||
sqlite_orm::make_column("head_commit_id",&RepoInfo::head_commit_id),
|
||||
sqlite_orm::make_column("enc_version",&RepoInfo::enc_version),
|
||||
sqlite_orm::make_column("salt",&RepoInfo::salt),
|
||||
sqlite_orm::make_column("magic",&RepoInfo::magic),
|
||||
sqlite_orm::make_column("random_key",&RepoInfo::random_key)
|
||||
),
|
||||
sqlite_orm::make_table("repo_entry",
|
||||
sqlite_orm::make_column("type",&RepoEntry::type),
|
||||
sqlite_orm::make_column("name",&RepoEntry::name),
|
||||
sqlite_orm::make_column("path",&RepoEntry::path),
|
||||
sqlite_orm::make_column("id", &RepoEntry::id, sqlite_orm::primary_key()),
|
||||
sqlite_orm::make_column("mtime",&RepoEntry::mtime),
|
||||
sqlite_orm::make_column("modifier_email",&RepoEntry::modifier_email),
|
||||
sqlite_orm::make_column("size",&RepoEntry::size),
|
||||
sqlite_orm::make_column("is_locked",&RepoEntry::is_locked),
|
||||
sqlite_orm::make_column("lock_owner",&RepoEntry::lock_owner),
|
||||
sqlite_orm::make_column("lock_time",&RepoEntry::lock_time),
|
||||
sqlite_orm::make_column("locked_by_me",&RepoEntry::locked_by_me),
|
||||
sqlite_orm::make_column("permission",&RepoEntry::permission),
|
||||
sqlite_orm::make_column("modifier_contact_email",&RepoEntry::modifier_contact_email),
|
||||
sqlite_orm::make_column("modifier_name",&RepoEntry::modifier_name),
|
||||
sqlite_orm::make_column("starred",&RepoEntry::starred))
|
||||
);
|
||||
//clang-format on
|
||||
}
|
||||
}
|
||||
|
||||
struct SeafileStore::Database
|
||||
{
|
||||
using Storage = decltype(make_storage(""));
|
||||
Storage storage;
|
||||
|
||||
explicit Database(const std::string& path)
|
||||
: storage(make_storage(path))
|
||||
{
|
||||
}
|
||||
};
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::auth()
|
||||
{
|
||||
if (const auto auth_info = this->api.auth(this->username, this->password))
|
||||
{
|
||||
return {};
|
||||
}
|
||||
else
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(auth_info.error()));
|
||||
}
|
||||
}
|
||||
|
||||
SeafileStore::SeafileStore(const std::string& db_path, const std::string& server, const std::string& user,
|
||||
const std::string& password) : api(server)
|
||||
{
|
||||
this->database = std::make_unique<Database>(db_path);
|
||||
this->username = user;
|
||||
this->password = password;
|
||||
this->api_server = server;
|
||||
}
|
||||
|
||||
tl::expected<RepoEntry, api::SeafileException> SeafileStore::findRepoEntry(
|
||||
const std::string& repo_id, const std::string& path)
|
||||
{
|
||||
auto& storage = this->database->storage;
|
||||
const auto entry = storage.get_optional<RepoEntry>(
|
||||
sqlite_orm::where(
|
||||
sqlite_orm::and_(
|
||||
sqlite_orm::c(&RepoEntry::path) == path,
|
||||
sqlite_orm::c(&RepoEntry::repo_id) == repo_id
|
||||
)
|
||||
));
|
||||
if (entry)
|
||||
{
|
||||
return *entry;
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException("entry not exists"));
|
||||
}
|
||||
|
||||
tl::expected<std::string, api::SeafileException> SeafileStore::defaultRepoId() const
|
||||
{
|
||||
const auto repo = this->api.defaultRepo();
|
||||
if (repo)
|
||||
{
|
||||
if (repo->exists)
|
||||
{
|
||||
return repo->repo_id.value();
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException("No default repo"));
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(repo.error()));
|
||||
}
|
||||
|
||||
tl::expected<bool, api::SeafileException> SeafileStore::checkIsUpdated(const std::string& repo_id)
|
||||
{
|
||||
auto& storage = this->database->storage;
|
||||
const auto repo = storage.get_optional<RepoInfo>(
|
||||
sqlite_orm::where(
|
||||
sqlite_orm::c(&RepoInfo::id) == repo_id
|
||||
));
|
||||
if (!repo)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
const auto& commit_id = repo.value().head_commit_id;
|
||||
const auto repo_info = this->api.repoInfo(repo_id);
|
||||
if (repo_info)
|
||||
{
|
||||
return repo_info.value().head_commit_id == commit_id;
|
||||
}
|
||||
|
||||
return tl::make_unexpected(repo_info.error());
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::syncRepoEntry(const std::string& repo_id) const
|
||||
{
|
||||
std::stack<RepoEntry> entry_stack;
|
||||
std::string path = "/";
|
||||
std::vector<RepoEntry> data;
|
||||
|
||||
entry_stack.push(RepoEntry{.repo_id = repo_id, .path = path});
|
||||
|
||||
while (!entry_stack.empty())
|
||||
{
|
||||
const auto parent = entry_stack.top();
|
||||
entry_stack.pop();
|
||||
path = parent.path;
|
||||
auto entries = this->api.repoDir(repo_id, path);
|
||||
if (!entries)
|
||||
{
|
||||
return tl::make_unexpected(entries.error());
|
||||
}
|
||||
for (auto& entry : *entries)
|
||||
{
|
||||
const auto entry_info = RepoEntry::from_api_model(repo_id, std::format("{}/{}", path, entry.name),
|
||||
entry);
|
||||
if (entry_info.type == "dir")
|
||||
{
|
||||
entry_stack.push(entry_info);
|
||||
}
|
||||
data.push_back(entry_info);
|
||||
}
|
||||
}
|
||||
try
|
||||
{
|
||||
this->database->storage.transaction([&]
|
||||
{
|
||||
for (const auto& entry : data)
|
||||
{
|
||||
this->database->storage.replace(entry);
|
||||
}
|
||||
return true;
|
||||
});
|
||||
}
|
||||
catch (std::exception& e)
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::checkAndSync(const std::string& repo_id)
|
||||
{
|
||||
if (!this->checkIsUpdated(repo_id))
|
||||
{
|
||||
return this->syncRepoEntry(repo_id);
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::init()
|
||||
{
|
||||
if (const auto& store_path = storePath(); !std::filesystem::exists(store_path))
|
||||
{
|
||||
try
|
||||
{
|
||||
this->database->storage.sync_schema();
|
||||
}
|
||||
catch (std::exception& e)
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
}
|
||||
const auto auth_token = this->auth();
|
||||
if (!auth_token)
|
||||
{
|
||||
return tl::make_unexpected(auth_token.error());
|
||||
}
|
||||
return this->sync();;
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::syncUserInfo()
|
||||
{
|
||||
const auto user_info = this->api.accountInfo();
|
||||
if (!user_info)
|
||||
{
|
||||
return tl::make_unexpected(user_info.error());
|
||||
}
|
||||
this->database->storage.replace(*user_info);
|
||||
return {};
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::syncRepos()
|
||||
{
|
||||
const auto repos = this->api.repos("mine", "");
|
||||
if (!repos)
|
||||
{
|
||||
return tl::make_unexpected(repos.error());
|
||||
}
|
||||
for (const auto& repo : *repos)
|
||||
{
|
||||
try
|
||||
{
|
||||
this->database->storage.replace(repo);
|
||||
}
|
||||
catch (std::exception& e)
|
||||
{
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
if (const auto sync_repo = syncRepoEntry(repo.id); !sync_repo)
|
||||
{
|
||||
return tl::make_unexpected(sync_repo.error());
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::sync()
|
||||
{
|
||||
if (const auto sync_account = this->syncUserInfo(); !sync_account)
|
||||
{
|
||||
return tl::make_unexpected(sync_account.error());
|
||||
}
|
||||
if (const auto sync_repos = syncRepos(); !sync_repos)
|
||||
{
|
||||
return tl::make_unexpected(sync_repos.error());
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
SeafileStore::~SeafileStore() = default;
|
||||
|
||||
std::filesystem::path SeafileStore::storePath()
|
||||
{
|
||||
return shell::util::ApplicationPath::get().parent_path() / "seafile.sqlite";
|
||||
}
|
||||
}
|
||||
#include "seafile/fs/seafile_store.hpp"
|
||||
|
||||
#include <sqlite_orm/sqlite_orm.h>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <format>
|
||||
|
||||
#include "seafile/api/account_info.hpp"
|
||||
#include "seafile/api/repo_info.hpp"
|
||||
#include "seafile/fs/storage/repo_entry.hpp"
|
||||
#include "seafile/fs/storage/repo_info.hpp"
|
||||
#include "util/application_path.hpp"
|
||||
#include "util/string_util.hpp"
|
||||
|
||||
namespace seafile::fs {
|
||||
using RepoEntry = storage::RepoEntry;
|
||||
using AccountInfo = api::AccountInfo;
|
||||
using RepoInfo = storage::RepoInfo;
|
||||
|
||||
namespace {
|
||||
std::string normalizePath(std::string path) {
|
||||
std::ranges::replace(path, '\\', '/');
|
||||
while (path.size() > 1 && path.back() == '/') {
|
||||
path.pop_back();
|
||||
}
|
||||
return path.empty() ? "/" : path;
|
||||
}
|
||||
|
||||
std::vector<std::string> splitPath(const std::string &path) {
|
||||
auto parts = shell::util::StringUtil::split(path, "/");
|
||||
std::erase(parts, "");
|
||||
return parts;
|
||||
}
|
||||
|
||||
std::string joinPath(const std::vector<std::string> &parts, const size_t start) {
|
||||
std::string result;
|
||||
for (size_t i = start; i < parts.size(); ++i) {
|
||||
if (!result.empty()) {
|
||||
result += '/';
|
||||
}
|
||||
result += parts[i];
|
||||
}
|
||||
return result.empty() ? "/" : "/" + result;
|
||||
}
|
||||
|
||||
std::string parentPath(const std::string &path) {
|
||||
if (path == "/") {
|
||||
return "/";
|
||||
}
|
||||
const auto pos = path.find_last_of('/');
|
||||
if (pos == std::string::npos || pos == 0) {
|
||||
return "/";
|
||||
}
|
||||
return path.substr(0, pos);
|
||||
}
|
||||
|
||||
auto make_storage(const std::string &path) {
|
||||
// clang-format off
|
||||
return sqlite_orm::make_storage(path,
|
||||
sqlite_orm::make_table("account_info",
|
||||
sqlite_orm::make_column("space_usage", &AccountInfo::space_usage),
|
||||
sqlite_orm::make_column("avatar_url", &AccountInfo::avatar_url),
|
||||
sqlite_orm::make_column("email", &AccountInfo::email, sqlite_orm::primary_key()),
|
||||
sqlite_orm::make_column("name", &AccountInfo::name),
|
||||
sqlite_orm::make_column("total", &AccountInfo::total),
|
||||
sqlite_orm::make_column("usage", &AccountInfo::usage),
|
||||
sqlite_orm::make_column("login_id", &AccountInfo::login_id),
|
||||
sqlite_orm::make_column("department", &AccountInfo::department),
|
||||
sqlite_orm::make_column("contact_email", &AccountInfo::contact_email),
|
||||
sqlite_orm::make_column("institution", &AccountInfo::institution),
|
||||
sqlite_orm::make_column("is_staff", &AccountInfo::is_staff),
|
||||
sqlite_orm::make_column("file_updates_email_interval", &AccountInfo::file_updates_email_interval),
|
||||
sqlite_orm::make_column("collaborate_email_interval", &AccountInfo::collaborate_email_interval)
|
||||
),
|
||||
sqlite_orm::make_table("repo_info",
|
||||
sqlite_orm::make_column("type", &RepoInfo::type),
|
||||
sqlite_orm::make_column("id", &RepoInfo::id, sqlite_orm::primary_key()),
|
||||
sqlite_orm::make_column("owner", &RepoInfo::owner),
|
||||
sqlite_orm::make_column("name", &RepoInfo::name),
|
||||
sqlite_orm::make_column("mtime", &RepoInfo::mtime),
|
||||
sqlite_orm::make_column("size", &RepoInfo::size),
|
||||
sqlite_orm::make_column("encrypted", &RepoInfo::encrypted),
|
||||
sqlite_orm::make_column("root", &RepoInfo::root),
|
||||
sqlite_orm::make_column("permission", &RepoInfo::permission),
|
||||
sqlite_orm::make_column("modifier_email", &RepoInfo::modifier_email),
|
||||
sqlite_orm::make_column("modifier_contact_email", &RepoInfo::modifier_contact_email),
|
||||
sqlite_orm::make_column("modifier_name", &RepoInfo::modifier_name),
|
||||
sqlite_orm::make_column("file_count", &RepoInfo::file_count),
|
||||
sqlite_orm::make_column("head_commit_id", &RepoInfo::head_commit_id),
|
||||
sqlite_orm::make_column("enc_version", &RepoInfo::enc_version),
|
||||
sqlite_orm::make_column("salt", &RepoInfo::salt),
|
||||
sqlite_orm::make_column("magic", &RepoInfo::magic),
|
||||
sqlite_orm::make_column("random_key", &RepoInfo::random_key)
|
||||
),
|
||||
sqlite_orm::make_table("repo_entry",
|
||||
sqlite_orm::make_column("repo_id", &RepoEntry::repo_id),
|
||||
sqlite_orm::make_column("type", &RepoEntry::type),
|
||||
sqlite_orm::make_column("name", &RepoEntry::name),
|
||||
sqlite_orm::make_column("path", &RepoEntry::path),
|
||||
sqlite_orm::make_column("id", &RepoEntry::id),
|
||||
sqlite_orm::make_column("mtime", &RepoEntry::mtime),
|
||||
sqlite_orm::make_column("modifier_email", &RepoEntry::modifier_email),
|
||||
sqlite_orm::make_column("size", &RepoEntry::size),
|
||||
sqlite_orm::make_column("is_locked", &RepoEntry::is_locked),
|
||||
sqlite_orm::make_column("lock_owner", &RepoEntry::lock_owner),
|
||||
sqlite_orm::make_column("lock_time", &RepoEntry::lock_time),
|
||||
sqlite_orm::make_column("locked_by_me", &RepoEntry::locked_by_me),
|
||||
sqlite_orm::make_column("permission", &RepoEntry::permission),
|
||||
sqlite_orm::make_column("modifier_contact_email", &RepoEntry::modifier_contact_email),
|
||||
sqlite_orm::make_column("modifier_name", &RepoEntry::modifier_name),
|
||||
sqlite_orm::make_column("starred", &RepoEntry::starred),
|
||||
sqlite_orm::primary_key(&RepoEntry::repo_id, &RepoEntry::path)
|
||||
)
|
||||
);
|
||||
//clang-format on
|
||||
}
|
||||
}
|
||||
|
||||
struct SeafileStore::Database {
|
||||
using Storage = decltype(make_storage(""));
|
||||
Storage storage;
|
||||
std::recursive_mutex mutex;
|
||||
|
||||
explicit Database(const std::string &path)
|
||||
: storage(make_storage(path)) {
|
||||
}
|
||||
};
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::auth() {
|
||||
const auto auth_info = this->api.auth(this->username, this->password);
|
||||
if (auth_info) {
|
||||
return {};
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(auth_info.error()));
|
||||
}
|
||||
|
||||
SeafileStore::SeafileStore(const std::string &db_path, const std::string &server, const std::string &user,
|
||||
const std::string &password) : api(server) {
|
||||
this->database = std::make_unique<Database>(db_path);
|
||||
this->username = user;
|
||||
this->password = password;
|
||||
this->api_server = server;
|
||||
}
|
||||
|
||||
tl::expected<RepoEntry, api::SeafileException> SeafileStore::findRepoEntry(
|
||||
const std::string &repo_id, const std::string &path) {
|
||||
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
const auto entries = storage.get_all<RepoEntry>(
|
||||
sqlite_orm::where(
|
||||
sqlite_orm::and_(
|
||||
sqlite_orm::c(&RepoEntry::repo_id) == repo_id,
|
||||
sqlite_orm::c(&RepoEntry::path) == path
|
||||
)
|
||||
));
|
||||
if (!entries.empty()) {
|
||||
return entries.at(0);
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException("entry not exists"));
|
||||
}
|
||||
|
||||
tl::expected<std::string, api::SeafileException> SeafileStore::defaultRepoId() const {
|
||||
const auto repo = this->api.defaultRepo();
|
||||
if (repo) {
|
||||
if (repo->exists) {
|
||||
return repo->repo_id.value();
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException("No default repo"));
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(repo.error()));
|
||||
}
|
||||
|
||||
tl::expected<bool, api::SeafileException> SeafileStore::checkIsUpdated(const std::string &repo_id) {
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
const auto repos = storage.get_all<RepoInfo>(
|
||||
sqlite_orm::where(
|
||||
sqlite_orm::c(&RepoInfo::id) == repo_id
|
||||
));
|
||||
if (repos.empty()) {
|
||||
return false;
|
||||
}
|
||||
const auto& repo = repos.at(0);
|
||||
const auto &commit_id = repo.head_commit_id;
|
||||
const auto repo_info = this->api.repoInfo(repo_id);
|
||||
if (repo_info) {
|
||||
return repo_info.value().head_commit_id == commit_id;
|
||||
}
|
||||
|
||||
return tl::make_unexpected(repo_info.error());
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::checkAndSync(const std::string &repo_id) {
|
||||
if (!this->checkIsUpdated(repo_id)) {
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
try {
|
||||
storage.remove<RepoEntry>(sqlite_orm::where(
|
||||
sqlite_orm::c(&RepoEntry::repo_id) == repo_id
|
||||
)
|
||||
);
|
||||
const auto repo_entries = this->api.repoDir(repo_id, "/");
|
||||
if (!repo_entries) {
|
||||
return tl::make_unexpected(repo_entries.error());
|
||||
}
|
||||
for (const auto &repo_entry: *repo_entries) {
|
||||
storage.replace(RepoEntry::from_api_model(repo_id, "/", repo_entry));
|
||||
}
|
||||
} catch (std::exception &e) {
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::init() {
|
||||
try {
|
||||
std::lock_guard lock(database->mutex);
|
||||
this->database->storage.sync_schema();
|
||||
} catch (std::exception &e) {
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
if (const auto auth_token = this->auth(); !auth_token) {
|
||||
return tl::make_unexpected(auth_token.error());
|
||||
}
|
||||
return this->sync();
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::syncUserInfo() {
|
||||
const auto user_info = this->api.accountInfo();
|
||||
if (!user_info) {
|
||||
return tl::make_unexpected(user_info.error());
|
||||
}
|
||||
std::lock_guard lock(database->mutex);
|
||||
this->database->storage.replace(*user_info);
|
||||
return {};
|
||||
}
|
||||
|
||||
tl::expected<std::vector<RepoInfo>, api::SeafileException> SeafileStore::syncRepos() {
|
||||
const auto repos = this->api.repos("mine", "");
|
||||
if (!repos) {
|
||||
return tl::make_unexpected(repos.error());
|
||||
}
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
std::vector<RepoInfo> result;
|
||||
result.reserve(repos->size());
|
||||
for (const auto &repo: *repos) {
|
||||
const auto storage_repo = RepoInfo::from_api_model(repo);
|
||||
result.push_back(storage_repo);
|
||||
try {
|
||||
const auto existings = storage.get_all<RepoInfo>(
|
||||
sqlite_orm::where(sqlite_orm::c(&RepoInfo::id) == storage_repo.id));
|
||||
std::optional<RepoInfo> existing = std::nullopt;
|
||||
if (!existings.empty()) {
|
||||
existing = existings.at(0);
|
||||
}
|
||||
if (existing && existing->head_commit_id != storage_repo.head_commit_id) {
|
||||
storage.remove<RepoEntry>(sqlite_orm::where(
|
||||
sqlite_orm::c(&RepoEntry::repo_id) == storage_repo.id));
|
||||
}
|
||||
storage.replace(storage_repo);
|
||||
} catch (std::exception &e) {
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
tl::expected<RepoInfo, api::SeafileException> SeafileStore::findRepoByName(const std::string &name) {
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
try {
|
||||
auto repos = storage.get_all<RepoInfo>(
|
||||
sqlite_orm::where(sqlite_orm::c(&RepoInfo::name) == name));
|
||||
if (!repos.empty()) {
|
||||
return repos.at(0);
|
||||
}
|
||||
if (const auto synced = this->syncRepos(); synced) {
|
||||
repos = storage.get_all<RepoInfo>(
|
||||
sqlite_orm::where(sqlite_orm::c(&RepoInfo::name) == name));
|
||||
if (!repos.empty()) {
|
||||
return repos.at(0);
|
||||
}
|
||||
} else {
|
||||
return tl::make_unexpected(synced.error());
|
||||
}
|
||||
}catch (const std::exception &e) {
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(std::format("repo not found: {}", name)));
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::fetchAndStoreRepoDir(
|
||||
const std::string &repo_id, const std::string &parent_path) {
|
||||
const auto entries = this->api.repoDir(repo_id, parent_path);
|
||||
if (!entries) {
|
||||
return tl::make_unexpected(entries.error());
|
||||
}
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
try {
|
||||
for (const auto &entry: *entries) {
|
||||
storage.replace(RepoEntry::from_api_model(repo_id, parent_path, entry));
|
||||
}
|
||||
} catch (std::exception &e) {
|
||||
return tl::make_unexpected(api::SeafileException(e.what()));
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
std::vector<RepoEntry> SeafileStore::queryDirectChildren(
|
||||
const std::string &repo_id, const std::string &parent_path) {
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
const std::string prefix = (parent_path == "/") ? "" : parent_path;
|
||||
const auto all = storage.get_all<RepoEntry>(
|
||||
sqlite_orm::where(
|
||||
sqlite_orm::and_(
|
||||
sqlite_orm::c(&RepoEntry::repo_id) == repo_id,
|
||||
sqlite_orm::like(&RepoEntry::path, prefix + "/%")
|
||||
)
|
||||
));
|
||||
std::vector<RepoEntry> children;
|
||||
for (auto &entry: all) {
|
||||
if (const auto rest = entry.path.substr(prefix.size() + 1); rest.find('/') == std::string::npos) {
|
||||
children.push_back(entry);
|
||||
}
|
||||
}
|
||||
return children;
|
||||
}
|
||||
|
||||
tl::expected<std::variant<RepoInfo, RepoEntry>, api::SeafileException> SeafileStore::pathInfo(
|
||||
const std::string &path) {
|
||||
const auto normalized = normalizePath(path);
|
||||
const auto parts = splitPath(normalized);
|
||||
if (parts.empty()) {
|
||||
return tl::make_unexpected(api::SeafileException("pathInfo does not support root path"));
|
||||
}
|
||||
|
||||
const auto &repo_name = parts[0];
|
||||
const auto repo = findRepoByName(repo_name);
|
||||
if (!repo) {
|
||||
return tl::make_unexpected(repo.error());
|
||||
}
|
||||
|
||||
if (parts.size() == 1) {
|
||||
return std::variant<RepoInfo, RepoEntry>(*repo);
|
||||
}
|
||||
|
||||
const auto inner_path = joinPath(parts, 1);
|
||||
auto entry = findRepoEntry(repo->id, inner_path);
|
||||
if (entry) {
|
||||
return std::variant<RepoInfo, RepoEntry>(*entry);
|
||||
}
|
||||
|
||||
const auto parent_path = parentPath(inner_path);
|
||||
if (const auto res = fetchAndStoreRepoDir(repo->id, parent_path); !res) {
|
||||
return tl::make_unexpected(res.error());
|
||||
}
|
||||
|
||||
entry = findRepoEntry(repo->id, inner_path);
|
||||
if (entry) {
|
||||
return std::variant<RepoInfo, RepoEntry>(*entry);
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException(std::format("path not found: {}", path)));
|
||||
}
|
||||
|
||||
tl::expected<std::variant<std::vector<RepoInfo>, std::vector<RepoEntry> >, api::SeafileException>
|
||||
SeafileStore::listDir(const std::string &path) {
|
||||
const auto normalized = normalizePath(path);
|
||||
const auto parts = splitPath(normalized);
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto &storage = this->database->storage;
|
||||
|
||||
if (parts.empty()) {
|
||||
auto repos = storage.get_all<RepoInfo>();
|
||||
if (repos.empty()) {
|
||||
if (const auto synced = this->syncRepos(); synced) {
|
||||
repos = storage.get_all<RepoInfo>();
|
||||
} else {
|
||||
return tl::make_unexpected(synced.error());
|
||||
}
|
||||
}
|
||||
return std::variant<std::vector<RepoInfo>, std::vector<RepoEntry> >(std::move(repos));
|
||||
}
|
||||
|
||||
const auto &repo_name = parts[0];
|
||||
const auto repo = findRepoByName(repo_name);
|
||||
if (!repo) {
|
||||
return tl::make_unexpected(repo.error());
|
||||
}
|
||||
|
||||
const auto inner_path = joinPath(parts, 1);
|
||||
auto children = queryDirectChildren(repo->id, inner_path);
|
||||
if (children.empty()) {
|
||||
if (const auto res = fetchAndStoreRepoDir(repo->id, inner_path); !res) {
|
||||
return tl::make_unexpected(res.error());
|
||||
}
|
||||
children = queryDirectChildren(repo->id, inner_path);
|
||||
}
|
||||
return std::variant<std::vector<RepoInfo>, std::vector<RepoEntry> >(std::move(children));
|
||||
}
|
||||
|
||||
tl::expected<std::string, api::SeafileException> SeafileStore::readFile(
|
||||
const std::string& repo_id, const std::string& path, const size_t offset, const size_t length) const {
|
||||
if (length == 0) {
|
||||
return std::string{};
|
||||
}
|
||||
return this->api.downloadFile(repo_id, path, offset, offset + length - 1);
|
||||
}
|
||||
|
||||
tl::expected<api::AccountInfo, api::SeafileException> SeafileStore::accountInfo() const {
|
||||
std::lock_guard lock(database->mutex);
|
||||
auto& storage = this->database->storage;
|
||||
if (const auto infos = storage.get_all<AccountInfo>(); !infos.empty()) {
|
||||
return infos.front();
|
||||
}
|
||||
return tl::make_unexpected(api::SeafileException("account info not synced"));
|
||||
}
|
||||
|
||||
tl::expected<void, api::SeafileException> SeafileStore::sync() {
|
||||
if (const auto sync_account = this->syncUserInfo(); !sync_account) {
|
||||
return tl::make_unexpected(sync_account.error());
|
||||
}
|
||||
if (const auto sync_repos = syncRepos(); !sync_repos) {
|
||||
return tl::make_unexpected(sync_repos.error());
|
||||
}
|
||||
return {};
|
||||
}
|
||||
|
||||
SeafileStore::~SeafileStore() = default;
|
||||
|
||||
std::filesystem::path SeafileStore::storePath() {
|
||||
return shell::util::ApplicationPath::get().parent_path() / "seafile.sqlite";
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user