Page MenuHomePhabricator
Differential D8338

[web] Use colors from themes.css in dropdown
ClosedPublic
Actions

Authored by rohan on Jun 27 2023, 11:26 AM.
Tags
None
Referenced Files
Unknown Object (File)
Thu, Apr 24, 5:17 PM
Unknown Object (File)
Sat, Apr 19, 12:07 PM
Unknown Object (File)
Fri, Apr 18, 8:45 AM
Unknown Object (File)
Fri, Apr 18, 7:06 AM
Unknown Object (File)
Fri, Apr 18, 6:55 AM
Unknown Object (File)
Thu, Apr 17, 4:44 PM
Unknown Object (File)
Tue, Apr 8, 11:17 PM
Unknown Object (File)
Tue, Apr 8, 10:35 PM
View All Files
Subscribers
• ted
tomek

Details

Reviewers
atul
ashoat
Commits
rCOMM2bb6d801c1fd: [web] Use colors from themes.css in dropdown
Summary

Some feedback in D8136 was to use colors from themes.css instead of inlining them in SWMansionIcon.

Depends on D8337

Test Plan

Confirmed that both enabled and disabled dropdowns still look the same

Diff Detail

Repository
rCOMM Comm
Branch
change_roles-quickfix
Lint
No Lint Coverage
Unit
No Test Coverage

Event Timeline

rohan created this revision.Jun 27 2023, 11:26 AM
Herald added subscribers: • ted, tomek. · View Herald TranscriptJun 27 2023, 11:26 AM
Harbormaster completed remote builds in B20553: Diff 28187.Jun 27 2023, 11:44 AM
rohan requested review of this revision.Jun 27 2023, 11:44 AM
rohan mentioned this in D8136: [web] Implement a custom dropdown menu component.Jun 27 2023, 12:12 PM
atul accepted this revision.Jun 28 2023, 10:26 AM

Let's make sure to fix typo before landing

web/components/dropdown.react.js
39 ↗(On Diff #28187)

Do we need !!disabled, or can we just do disabled?

web/theme.css
235 ↗(On Diff #28187)

Minor typo, should be dropdown instead of dropddown

This revision is now accepted and ready to land.Jun 28 2023, 10:26 AM
atul added inline comments.Jun 28 2023, 10:28 AM
web/components/dropdown.react.js
39 ↗(On Diff #28187)

I guess we do !!disabled above in the other calls to classNames, so it's probably best to maintain consistency.

rohan added inline comments.Jun 28 2023, 10:34 AM
web/theme.css
235 ↗(On Diff #28187)

Oh yeah thanks for catching that

rohan updated this revision to Diff 28215.Jun 28 2023, 10:35 AM

Typo

This revision was landed with ongoing or failed builds.Jun 28 2023, 10:38 AM
Closed by commit rCOMM2bb6d801c1fd: [web] Use colors from themes.css in dropdown (authored by rohan). · Explain Why
This revision was automatically updated to reflect the committed changes.
rohan added a commit: rCOMM2bb6d801c1fd: [web] Use colors from themes.css in dropdown.
Harbormaster completed remote builds in B20580: Diff 28215.Jun 28 2023, 10:52 AM

Revision Contents
Changeset List

PathSize
web/
components/
1 line
8 lines
1 line

Diff 28215

View Options

web/components/dropdown.css

Show First 20 Lines • Show All 487 Lines • ▼ Show 20 Lines attempt_delete_file(
"Failed to delete unencrypted database."); "Failed to delete unencrypted database.");
attempt_rename_file( attempt_rename_file(
temp_encrypted_db_path, temp_encrypted_db_path,
SQLiteQueryExecutor::sqliteFilePath, SQLiteQueryExecutor::sqliteFilePath,
"Failed to move encrypted database to default location."); "Failed to move encrypted database to default location.");
Logger::log("Encryption completed successfully."); Logger::log("Encryption completed successfully.");
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
typedef bool ShouldBeInTransaction; typedef bool ShouldBeInTransaction;
typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction> typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction>
SQLiteMigration; SQLiteMigration;
std::vector<std::pair<uint, SQLiteMigration>> migrations{ std::vector<std::pair<uint, SQLiteMigration>> migrations{
{{1, {create_drafts_table, true}}, {{1, {create_drafts_table, true}},
{2, {rename_threadID_to_key, true}}, {2, {rename_threadID_to_key, true}},
{4, {create_persist_account_table, true}}, {4, {create_persist_account_table, true}},
{5, {create_persist_sessions_table, true}}, {5, {create_persist_sessions_table, true}},
Show All 28 Linesvoid SQLiteQueryExecutor::migrate() const {
int current_user_version = sqlite3_column_int(user_version_stmt, 0); int current_user_version = sqlite3_column_int(user_version_stmt, 0);
sqlite3_finalize(user_version_stmt); sqlite3_finalize(user_version_stmt);
std::stringstream version_msg; std::stringstream version_msg;
version_msg << "db version: " << current_user_version << std::endl; version_msg << "db version: " << current_user_version << std::endl;
Logger::log(version_msg.str()); Logger::log(version_msg.str());
if (current_user_version == 0) {
SQLiteQueryExecutor::getStorage().sync_schema();
Logger::log("Creating new database, syncing structure with ORM storage.");
auto latest_version = migrations.back().first;
std::stringstream update_version;
update_version << "PRAGMA user_version=" << latest_version << ";";
auto update_version_str = update_version.str();
char *error;
sqlite3_exec(db, update_version_str.c_str(), nullptr, nullptr, &error);
if (error) {
std::ostringstream errorStream;
errorStream << "Error saving database version: " << error;
Logger::log(errorStream.str());
marcinUnsubmitted
Not Done
Inline Actions

How is application going to function if this error occurs? In most places we the runtime error to kill the app if database operation fails since application is not going to work correctly. I just want to know whether it is also the case here.

marcin: How is application going to function if this error occurs? In most places we the runtime error…
sqlite3_free(error);
}
return;
}
for (const auto &[idx, migration] : migrations) { for (const auto &[idx, migration] : migrations) {
if (idx <= current_user_version) { if (idx <= current_user_version) {
continue; continue;
} }
const auto &[applyMigration, shouldBeInTransaction] = migration; const auto &[applyMigration, shouldBeInTransaction] = migration;
std::stringstream migration_msg; std::stringstream migration_msg;
Show All 28 Linesvoid SQLiteQueryExecutor::assign_encryption_key() {
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
std::string encryptionKey = comm::crypto::Tools::generateRandomHexString( std::string encryptionKey = comm::crypto::Tools::generateRandomHexString(
SQLiteQueryExecutor::sqlcipherEncryptionKeySize); SQLiteQueryExecutor::sqlcipherEncryptionKeySize);
commSecureStore.set( commSecureStore.set(
SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey); SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey);
SQLiteQueryExecutor::encryptionKey = encryptionKey; SQLiteQueryExecutor::encryptionKey = encryptionKey;
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
void SQLiteQueryExecutor::initialize(std::string &databasePath) { void SQLiteQueryExecutor::initialize(std::string &databasePath) {
std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() { std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() {
SQLiteQueryExecutor::sqliteFilePath = databasePath; SQLiteQueryExecutor::sqliteFilePath = databasePath;
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
folly::Optional<std::string> maybeEncryptionKey = folly::Optional<std::string> maybeEncryptionKey =
commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID); commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID);
if (file_exists(databasePath) && maybeEncryptionKey) { if (file_exists(databasePath) && maybeEncryptionKey) {
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines
View Options

web/components/dropdown.react.js

Show First 20 Lines • Show All 487 Lines • ▼ Show 20 Lines attempt_delete_file(
"Failed to delete unencrypted database."); "Failed to delete unencrypted database.");
attempt_rename_file( attempt_rename_file(
temp_encrypted_db_path, temp_encrypted_db_path,
SQLiteQueryExecutor::sqliteFilePath, SQLiteQueryExecutor::sqliteFilePath,
"Failed to move encrypted database to default location."); "Failed to move encrypted database to default location.");
Logger::log("Encryption completed successfully."); Logger::log("Encryption completed successfully.");
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
typedef bool ShouldBeInTransaction; typedef bool ShouldBeInTransaction;
typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction> typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction>
SQLiteMigration; SQLiteMigration;
std::vector<std::pair<uint, SQLiteMigration>> migrations{ std::vector<std::pair<uint, SQLiteMigration>> migrations{
{{1, {create_drafts_table, true}}, {{1, {create_drafts_table, true}},
{2, {rename_threadID_to_key, true}}, {2, {rename_threadID_to_key, true}},
{4, {create_persist_account_table, true}}, {4, {create_persist_account_table, true}},
{5, {create_persist_sessions_table, true}}, {5, {create_persist_sessions_table, true}},
Show All 28 Linesvoid SQLiteQueryExecutor::migrate() const {
int current_user_version = sqlite3_column_int(user_version_stmt, 0); int current_user_version = sqlite3_column_int(user_version_stmt, 0);
sqlite3_finalize(user_version_stmt); sqlite3_finalize(user_version_stmt);
std::stringstream version_msg; std::stringstream version_msg;
version_msg << "db version: " << current_user_version << std::endl; version_msg << "db version: " << current_user_version << std::endl;
Logger::log(version_msg.str()); Logger::log(version_msg.str());
if (current_user_version == 0) {
SQLiteQueryExecutor::getStorage().sync_schema();
Logger::log("Creating new database, syncing structure with ORM storage.");
auto latest_version = migrations.back().first;
std::stringstream update_version;
update_version << "PRAGMA user_version=" << latest_version << ";";
auto update_version_str = update_version.str();
char *error;
sqlite3_exec(db, update_version_str.c_str(), nullptr, nullptr, &error);
if (error) {
std::ostringstream errorStream;
errorStream << "Error saving database version: " << error;
Logger::log(errorStream.str());
marcinUnsubmitted
Not Done
Inline Actions

How is application going to function if this error occurs? In most places we the runtime error to kill the app if database operation fails since application is not going to work correctly. I just want to know whether it is also the case here.

marcin: How is application going to function if this error occurs? In most places we the runtime error…
sqlite3_free(error);
}
return;
}
for (const auto &[idx, migration] : migrations) { for (const auto &[idx, migration] : migrations) {
if (idx <= current_user_version) { if (idx <= current_user_version) {
continue; continue;
} }
const auto &[applyMigration, shouldBeInTransaction] = migration; const auto &[applyMigration, shouldBeInTransaction] = migration;
std::stringstream migration_msg; std::stringstream migration_msg;
Show All 28 Linesvoid SQLiteQueryExecutor::assign_encryption_key() {
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
std::string encryptionKey = comm::crypto::Tools::generateRandomHexString( std::string encryptionKey = comm::crypto::Tools::generateRandomHexString(
SQLiteQueryExecutor::sqlcipherEncryptionKeySize); SQLiteQueryExecutor::sqlcipherEncryptionKeySize);
commSecureStore.set( commSecureStore.set(
SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey); SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey);
SQLiteQueryExecutor::encryptionKey = encryptionKey; SQLiteQueryExecutor::encryptionKey = encryptionKey;
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
void SQLiteQueryExecutor::initialize(std::string &databasePath) { void SQLiteQueryExecutor::initialize(std::string &databasePath) {
std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() { std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() {
SQLiteQueryExecutor::sqliteFilePath = databasePath; SQLiteQueryExecutor::sqliteFilePath = databasePath;
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
folly::Optional<std::string> maybeEncryptionKey = folly::Optional<std::string> maybeEncryptionKey =
commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID); commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID);
if (file_exists(databasePath) && maybeEncryptionKey) { if (file_exists(databasePath) && maybeEncryptionKey) {
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines
View Options

web/theme.css

Show First 20 Lines • Show All 487 Lines • ▼ Show 20 Lines attempt_delete_file(
"Failed to delete unencrypted database."); "Failed to delete unencrypted database.");
attempt_rename_file( attempt_rename_file(
temp_encrypted_db_path, temp_encrypted_db_path,
SQLiteQueryExecutor::sqliteFilePath, SQLiteQueryExecutor::sqliteFilePath,
"Failed to move encrypted database to default location."); "Failed to move encrypted database to default location.");
Logger::log("Encryption completed successfully."); Logger::log("Encryption completed successfully.");
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
typedef bool ShouldBeInTransaction; typedef bool ShouldBeInTransaction;
typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction> typedef std::pair<std::function<bool(sqlite3 *)>, ShouldBeInTransaction>
SQLiteMigration; SQLiteMigration;
std::vector<std::pair<uint, SQLiteMigration>> migrations{ std::vector<std::pair<uint, SQLiteMigration>> migrations{
{{1, {create_drafts_table, true}}, {{1, {create_drafts_table, true}},
{2, {rename_threadID_to_key, true}}, {2, {rename_threadID_to_key, true}},
{4, {create_persist_account_table, true}}, {4, {create_persist_account_table, true}},
{5, {create_persist_sessions_table, true}}, {5, {create_persist_sessions_table, true}},
Show All 28 Linesvoid SQLiteQueryExecutor::migrate() const {
int current_user_version = sqlite3_column_int(user_version_stmt, 0); int current_user_version = sqlite3_column_int(user_version_stmt, 0);
sqlite3_finalize(user_version_stmt); sqlite3_finalize(user_version_stmt);
std::stringstream version_msg; std::stringstream version_msg;
version_msg << "db version: " << current_user_version << std::endl; version_msg << "db version: " << current_user_version << std::endl;
Logger::log(version_msg.str()); Logger::log(version_msg.str());
if (current_user_version == 0) {
SQLiteQueryExecutor::getStorage().sync_schema();
Logger::log("Creating new database, syncing structure with ORM storage.");
auto latest_version = migrations.back().first;
std::stringstream update_version;
update_version << "PRAGMA user_version=" << latest_version << ";";
auto update_version_str = update_version.str();
char *error;
sqlite3_exec(db, update_version_str.c_str(), nullptr, nullptr, &error);
if (error) {
std::ostringstream errorStream;
errorStream << "Error saving database version: " << error;
Logger::log(errorStream.str());
marcinUnsubmitted
Not Done
Inline Actions

How is application going to function if this error occurs? In most places we the runtime error to kill the app if database operation fails since application is not going to work correctly. I just want to know whether it is also the case here.

marcin: How is application going to function if this error occurs? In most places we the runtime error…
sqlite3_free(error);
}
return;
}
for (const auto &[idx, migration] : migrations) { for (const auto &[idx, migration] : migrations) {
if (idx <= current_user_version) { if (idx <= current_user_version) {
continue; continue;
} }
const auto &[applyMigration, shouldBeInTransaction] = migration; const auto &[applyMigration, shouldBeInTransaction] = migration;
std::stringstream migration_msg; std::stringstream migration_msg;
Show All 28 Linesvoid SQLiteQueryExecutor::assign_encryption_key() {
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
std::string encryptionKey = comm::crypto::Tools::generateRandomHexString( std::string encryptionKey = comm::crypto::Tools::generateRandomHexString(
SQLiteQueryExecutor::sqlcipherEncryptionKeySize); SQLiteQueryExecutor::sqlcipherEncryptionKeySize);
commSecureStore.set( commSecureStore.set(
SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey); SQLiteQueryExecutor::secureStoreEncryptionKeyID, encryptionKey);
SQLiteQueryExecutor::encryptionKey = encryptionKey; SQLiteQueryExecutor::encryptionKey = encryptionKey;
} }
auto &SQLiteQueryExecutor::getStorage() {
static auto storage = make_storage(
SQLiteQueryExecutor::sqliteFilePath,
make_index("messages_idx_thread_time", &Message::thread, &Message::time),
make_index("media_idx_container", &Media::container),
make_table(
"drafts",
make_column("key", &Draft::key, unique(), primary_key()),
make_column("text", &Draft::text)),
make_table(
"messages",
make_column("id", &Message::id, unique(), primary_key()),
make_column("local_id", &Message::local_id),
make_column("thread", &Message::thread),
make_column("user", &Message::user),
make_column("type", &Message::type),
make_column("future_type", &Message::future_type),
make_column("content", &Message::content),
make_column("time", &Message::time)),
make_table(
"olm_persist_account",
make_column("id", &OlmPersistAccount::id, unique(), primary_key()),
make_column("account_data", &OlmPersistAccount::account_data)),
make_table(
"olm_persist_sessions",
make_column(
"target_user_id",
&OlmPersistSession::target_user_id,
unique(),
primary_key()),
make_column("session_data", &OlmPersistSession::session_data)),
make_table(
"media",
make_column("id", &Media::id, unique(), primary_key()),
make_column("container", &Media::container),
make_column("thread", &Media::thread),
make_column("uri", &Media::uri),
make_column("type", &Media::type),
make_column("extras", &Media::extras)),
make_table(
"threads",
make_column("id", &Thread::id, unique(), primary_key()),
make_column("type", &Thread::type),
make_column("name", &Thread::name),
make_column("description", &Thread::description),
make_column("color", &Thread::color),
make_column("creation_time", &Thread::creation_time),
make_column("parent_thread_id", &Thread::parent_thread_id),
make_column("containing_thread_id", &Thread::containing_thread_id),
make_column("community", &Thread::community),
make_column("members", &Thread::members),
make_column("roles", &Thread::roles),
make_column("current_user", &Thread::current_user),
make_column("source_message_id", &Thread::source_message_id),
make_column("replies_count", &Thread::replies_count)),
make_table(
"metadata",
make_column("name", &Metadata::name, unique(), primary_key()),
make_column("data", &Metadata::data)));
storage.on_open = on_database_open;
return storage;
}
void SQLiteQueryExecutor::initialize(std::string &databasePath) { void SQLiteQueryExecutor::initialize(std::string &databasePath) {
std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() { std::call_once(SQLiteQueryExecutor::initialized, [&databasePath]() {
SQLiteQueryExecutor::sqliteFilePath = databasePath; SQLiteQueryExecutor::sqliteFilePath = databasePath;
CommSecureStore commSecureStore{}; CommSecureStore commSecureStore{};
folly::Optional<std::string> maybeEncryptionKey = folly::Optional<std::string> maybeEncryptionKey =
commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID); commSecureStore.get(SQLiteQueryExecutor::secureStoreEncryptionKeyID);
if (file_exists(databasePath) && maybeEncryptionKey) { if (file_exists(databasePath) && maybeEncryptionKey) {
▲ Show 20 Lines • Show All 277 Lines • Show Last 20 Lines