shell/seadisk
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

clean seafile api

Browse Source
This commit is contained in:
shell committed 2026-07-21 22:00:38 +08:00
1 parent 133424f5f8
commit 3e4694ceb5
14 files changed
+476 -290
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

src/seafile/fs/seafile_store.cpp
+66 -70
View File
@@ -7,20 +7,18 @@
#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
{
namespace seafile::fs {
using RepoEntry = storage::RepoEntry;
using AccountInfo = api::AccountInfo;
using RepoInfo = api::RepoInfo;
namespace
{
auto make_storage(const std::string& path)
{
namespace {
auto make_storage(const std::string &path) {
// clang-format off
return sqlite_orm::make_storage(path,
sqlite_orm::make_table("account_info",
@@ -30,7 +28,7 @@ namespace seafile::fs
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("login_id", &AccountInfo::login_id,sqlite_orm::primary_key()),
sqlite_orm::make_column("department", &AccountInfo::department),
sqlite_orm::make_column("contact_email", &AccountInfo::contact_email),
sqlite_orm::make_column("institution", &AccountInfo::institution),
@@ -79,44 +77,34 @@ namespace seafile::fs
}
}
struct SeafileStore::Database
{
struct SeafileStore::Database {
using Storage = decltype(make_storage(""));
Storage storage;
explicit Database(const std::string& path)
: storage(make_storage(path))
{
explicit Database(const std::string &path)
: storage(make_storage(path)) {
}
};
tl::expected<void, api::SeafileException> SeafileStore::auth()
{
if (const auto auth_info = this->api.authToken(this->user, this->password))
{
this->token = auth_info->token;
this->token_type = api::TokenType::TOKEN;
tl::expected<void, api::SeafileException> SeafileStore::auth() {
if (const auto auth_info = this->api.auth(this->username, this->password)) {
return {};
}
else
{
} 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)
{
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->user = user;
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 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_(
@@ -124,20 +112,16 @@ namespace seafile::fs
sqlite_orm::c(&RepoEntry::repo_id) == repo_id
)
));
if (entry)
{
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(this->token,this->token_type);
if (repo)
{
if (repo->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"));
@@ -145,78 +129,90 @@ namespace seafile::fs
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;
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)
{
if (!repo) {
return false;
}
const auto& commit_id = repo.value().head_commit_id;
const auto repo_info = this->api.repoInfo(repo_id, this->token, this->token_type);
if (repo_info)
{
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::sync(const std::string& repo_id) const
{
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())
{
while (!entry_stack.empty()) {
const auto parent = entry_stack.top();
entry_stack.pop();
path = parent.path;
auto entries = this->api.repoDir(repo_id, path, this->token, this->token_type);
if (!entries)
{
auto entries = this->api.repoDir(repo_id, path);
if (!entries) {
return tl::make_unexpected(entries.error());
}
for (auto& entry : *entries)
{
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")
{
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)
{
}
try {
this->database->storage.transaction([&] {
for (const auto &entry: data) {
this->database->storage.insert(entry);
}
return true;
});
}catch (std::exception& e)
{
} 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->sync(repo_id);
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 = this->storePath(); !std::filesystem::exists(store_path)) {
this->database->storage.sync_schema();
return this->sync();
}
return {};
}
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() {
return {};
}
std::filesystem::path SeafileStore::storePath() const {
return shell::util::ApplicationPath::get() / "seafile.sqlite";
}
}