Page MenuHomePhabricator
Differential D7896

[native] Introduce UsernameSelection screen
ClosedPublic
Actions

Authored by ashoat on May 20 2023, 5:31 AM.
Tags
None
Referenced Files
Unknown Object (File)
Wed, Apr 2, 1:01 AM
Unknown Object (File)
Wed, Apr 2, 12:54 AM
Unknown Object (File)
Tue, Apr 1, 3:49 PM
Unknown Object (File)
Mar 2 2025, 1:34 PM
Unknown Object (File)
Mar 2 2025, 1:34 PM
Unknown Object (File)
Mar 2 2025, 1:34 PM
Unknown Object (File)
Mar 1 2025, 11:31 PM
Unknown Object (File)
Mar 1 2025, 11:31 PM
View All Files
Subscribers
tomek

Details

Reviewers
ginsu
atul
Commits
rCOMM3cae1466e7bb: [native] Introduce UsernameSelection screen
Summary

This screen will be used for selecting a username for non-ETH accounts. Eventually we'll also allow ETH accounts to set a username.

This diff just sets up the scaffolding for the page. Later diffs will add functionality.

Depends on D7895

Test Plan

Here's what it looks like now:

Screenshot 2023-05-20 at 8.28.32 AM.png (2×1 px, 342 KB)

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

PathSize
native/
account/
registration/
15 lines
6 lines
55 lines
navigation/
3 lines

Diff 26804

View Options

native/account/registration/connect-ethereum.react.js

#include "CreateNewBackupReactor.h" #include "CreateNewBackupReactor.h"
#include "DatabaseManager.h" #include "DatabaseManager.h"
#include "GlobalTools.h" #include "GlobalTools.h"
#include "Tools.h" #include "Tools.h"
#include "blob_client/src/lib.rs.h"
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
std::string CreateNewBackupReactor::generateBackupID() { std::string CreateNewBackupReactor::generateBackupID() {
if (this->deviceID.empty()) { if (this->deviceID.empty()) {
throw std::runtime_error( throw std::runtime_error(
"trying to generate a backup ID with an empty device ID"); "trying to generate a backup ID with an empty device ID");
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
if (database::DatabaseManager::getInstance().findBackupItem( if (database::DatabaseManager::getInstance().findBackupItem(
this->userID, this->backupID) != nullptr) { this->userID, this->backupID) != nullptr) {
throw std::runtime_error( throw std::runtime_error(
"Backup with id [" + this->backupID + "] for user [" + "Backup with id [" + this->backupID + "] for user [" +
this->userID + "] already exists, creation aborted"); this->userID + "] already exists, creation aborted");
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
// todo:blob perform put:initialize try {
put_client_initialize_cxx();
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str());
rust::String responseStr =
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true);
}
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
// todo:blob perform put:add chunk if (request.mutable_newcompactionchunk()->empty()) {
// (std::move(*request.mutable_newcompactionchunk()) return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
}
try {
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex); const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
// todo:blob perform put:add chunk ("") try {
// todo:blob perform put:wait for completion put_client_terminate_cxx();
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
// TODO add recovery data // TODO add recovery data
// TODO handle attachments holders // TODO handle attachments holders
database::BackupItem backupItem( database::BackupItem backupItem(
this->userID, this->userID,
this->backupID, this->backupID,
tools::getCurrentTimestamp(), tools::getCurrentTimestamp(),
tools::generateRandomString(), tools::generateRandomString(),
this->holder, this->holder,
{}); {});
database::DatabaseManager::getInstance().putBackupItem(backupItem); database::DatabaseManager::getInstance().putBackupItem(backupItem);
} }
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

native/account/registration/registration-navigator.react.js

#include "CreateNewBackupReactor.h" #include "CreateNewBackupReactor.h"
#include "DatabaseManager.h" #include "DatabaseManager.h"
#include "GlobalTools.h" #include "GlobalTools.h"
#include "Tools.h" #include "Tools.h"
#include "blob_client/src/lib.rs.h"
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
std::string CreateNewBackupReactor::generateBackupID() { std::string CreateNewBackupReactor::generateBackupID() {
if (this->deviceID.empty()) { if (this->deviceID.empty()) {
throw std::runtime_error( throw std::runtime_error(
"trying to generate a backup ID with an empty device ID"); "trying to generate a backup ID with an empty device ID");
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
if (database::DatabaseManager::getInstance().findBackupItem( if (database::DatabaseManager::getInstance().findBackupItem(
this->userID, this->backupID) != nullptr) { this->userID, this->backupID) != nullptr) {
throw std::runtime_error( throw std::runtime_error(
"Backup with id [" + this->backupID + "] for user [" + "Backup with id [" + this->backupID + "] for user [" +
this->userID + "] already exists, creation aborted"); this->userID + "] already exists, creation aborted");
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
// todo:blob perform put:initialize try {
put_client_initialize_cxx();
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str());
rust::String responseStr =
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true);
}
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
// todo:blob perform put:add chunk if (request.mutable_newcompactionchunk()->empty()) {
// (std::move(*request.mutable_newcompactionchunk()) return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
}
try {
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex); const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
// todo:blob perform put:add chunk ("") try {
// todo:blob perform put:wait for completion put_client_terminate_cxx();
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
// TODO add recovery data // TODO add recovery data
// TODO handle attachments holders // TODO handle attachments holders
database::BackupItem backupItem( database::BackupItem backupItem(
this->userID, this->userID,
this->backupID, this->backupID,
tools::getCurrentTimestamp(), tools::getCurrentTimestamp(),
tools::generateRandomString(), tools::generateRandomString(),
this->holder, this->holder,
{}); {});
database::DatabaseManager::getInstance().putBackupItem(backupItem); database::DatabaseManager::getInstance().putBackupItem(backupItem);
} }
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

native/account/registration/username-selection.react.js

#include "CreateNewBackupReactor.h" #include "CreateNewBackupReactor.h"
#include "DatabaseManager.h" #include "DatabaseManager.h"
#include "GlobalTools.h" #include "GlobalTools.h"
#include "Tools.h" #include "Tools.h"
#include "blob_client/src/lib.rs.h"
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
std::string CreateNewBackupReactor::generateBackupID() { std::string CreateNewBackupReactor::generateBackupID() {
if (this->deviceID.empty()) { if (this->deviceID.empty()) {
throw std::runtime_error( throw std::runtime_error(
"trying to generate a backup ID with an empty device ID"); "trying to generate a backup ID with an empty device ID");
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
if (database::DatabaseManager::getInstance().findBackupItem( if (database::DatabaseManager::getInstance().findBackupItem(
this->userID, this->backupID) != nullptr) { this->userID, this->backupID) != nullptr) {
throw std::runtime_error( throw std::runtime_error(
"Backup with id [" + this->backupID + "] for user [" + "Backup with id [" + this->backupID + "] for user [" +
this->userID + "] already exists, creation aborted"); this->userID + "] already exists, creation aborted");
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
// todo:blob perform put:initialize try {
put_client_initialize_cxx();
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str());
rust::String responseStr =
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true);
}
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
// todo:blob perform put:add chunk if (request.mutable_newcompactionchunk()->empty()) {
// (std::move(*request.mutable_newcompactionchunk()) return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
}
try {
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex); const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
// todo:blob perform put:add chunk ("") try {
// todo:blob perform put:wait for completion put_client_terminate_cxx();
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
// TODO add recovery data // TODO add recovery data
// TODO handle attachments holders // TODO handle attachments holders
database::BackupItem backupItem( database::BackupItem backupItem(
this->userID, this->userID,
this->backupID, this->backupID,
tools::getCurrentTimestamp(), tools::getCurrentTimestamp(),
tools::generateRandomString(), tools::generateRandomString(),
this->holder, this->holder,
{}); {});
database::DatabaseManager::getInstance().putBackupItem(backupItem); database::DatabaseManager::getInstance().putBackupItem(backupItem);
} }
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm
View Options

native/navigation/route-names.js

#include "CreateNewBackupReactor.h" #include "CreateNewBackupReactor.h"
#include "DatabaseManager.h" #include "DatabaseManager.h"
#include "GlobalTools.h" #include "GlobalTools.h"
#include "Tools.h" #include "Tools.h"
#include "blob_client/src/lib.rs.h"
namespace comm { namespace comm {
namespace network { namespace network {
namespace reactor { namespace reactor {
std::string CreateNewBackupReactor::generateBackupID() { std::string CreateNewBackupReactor::generateBackupID() {
if (this->deviceID.empty()) { if (this->deviceID.empty()) {
throw std::runtime_error( throw std::runtime_error(
"trying to generate a backup ID with an empty device ID"); "trying to generate a backup ID with an empty device ID");
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines case State::DATA_HASH: {
if (database::DatabaseManager::getInstance().findBackupItem( if (database::DatabaseManager::getInstance().findBackupItem(
this->userID, this->backupID) != nullptr) { this->userID, this->backupID) != nullptr) {
throw std::runtime_error( throw std::runtime_error(
"Backup with id [" + this->backupID + "] for user [" + "Backup with id [" + this->backupID + "] for user [" +
this->userID + "] already exists, creation aborted"); this->userID + "] already exists, creation aborted");
} }
response->set_backupid(this->backupID); response->set_backupid(this->backupID);
this->holder = tools::generateHolder(this->dataHash, this->backupID); this->holder = tools::generateHolder(this->dataHash, this->backupID);
// todo:blob perform put:initialize try {
put_client_initialize_cxx();
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kHolder),
this->holder.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kBlobHash),
this->dataHash.c_str());
rust::String responseStr =
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably
// want to delegate performing ops
// to separate threads in the base
// reactors
// data exists?
if ((bool)tools::charPtrToInt(responseStr.c_str())) {
return std::make_unique<ServerBidiReactorStatus>(
grpc::Status::OK, true);
}
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
case State::DATA_CHUNKS: { case State::DATA_CHUNKS: {
// todo:blob perform put:add chunk if (request.mutable_newcompactionchunk()->empty()) {
// (std::move(*request.mutable_newcompactionchunk()) return std::make_unique<ServerBidiReactorStatus>(grpc::Status::OK);
}
try {
put_client_write_cxx(
tools::getBlobPutField(blob::PutRequest::DataCase::kDataChunk),
std::string(std::move(*request.mutable_newcompactionchunk()))
.c_str());
put_client_blocking_read_cxx(); // todo this should be avoided
// (blocking); we should be able to
// ignore responses; we probably want to
// delegate performing ops to separate
// threads in the base reactors
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
return nullptr; return nullptr;
} }
} }
throw std::runtime_error("new backup - invalid state"); throw std::runtime_error("new backup - invalid state");
} }
void CreateNewBackupReactor::terminateCallback() { void CreateNewBackupReactor::terminateCallback() {
const std::lock_guard<std::mutex> lock(this->reactorStateMutex); const std::lock_guard<std::mutex> lock(this->reactorStateMutex);
// todo:blob perform put:add chunk ("") try {
// todo:blob perform put:wait for completion put_client_terminate_cxx();
} catch (std::exception &e) {
throw std::runtime_error(
e.what()); // todo in base reactors we can just handle std exception
// instead of keep rethrowing here
}
// TODO add recovery data // TODO add recovery data
// TODO handle attachments holders // TODO handle attachments holders
database::BackupItem backupItem( database::BackupItem backupItem(
this->userID, this->userID,
this->backupID, this->backupID,
tools::getCurrentTimestamp(), tools::getCurrentTimestamp(),
tools::generateRandomString(), tools::generateRandomString(),
this->holder, this->holder,
{}); {});
database::DatabaseManager::getInstance().putBackupItem(backupItem); database::DatabaseManager::getInstance().putBackupItem(backupItem);
} }
} // namespace reactor } // namespace reactor
} // namespace network } // namespace network
} // namespace comm } // namespace comm