Page MenuHomePhabricator
Differential D14062

[web] remove password change feature
ClosedPublic
Actions

Authored by kamil on Nov 28 2024, 5:09 AM.
Tags
None
Referenced Files
F6181686: D14062.id46203.diff
Wed, Apr 23, 7:07 AM
F6179620: D14062.id46185.diff
Wed, Apr 23, 5:10 AM
Unknown Object (File)
Wed, Apr 23, 12:24 AM
Unknown Object (File)
Tue, Apr 22, 9:28 PM
Unknown Object (File)
Mon, Apr 21, 8:23 PM
Unknown Object (File)
Fri, Apr 11, 7:35 PM
Unknown Object (File)
Mar 8 2025, 11:21 AM
Unknown Object (File)
Mar 8 2025, 11:20 AM
View All 58 Files
Subscribers
tomek

Details

Reviewers
ashoat
varun
Commits
rCOMMff76ebb3f095: [web] remove password change feature
Summary

This was discussed in ENG-8070

Only the primary device should be able to change the password.

Perhaps there was some alternative to keep this for a while and disable this after the user migrated to Signed Device Lists (v2), but this is not easy and probably there is no need to complicate just to keep this screen for a ~month and then remove.

Test Plan

No option to change password in account settings screen

Diff Detail

Repository
rCOMM Comm
Lint
Lint Not Applicable
Unit
Tests Not Applicable

Revision Contents
Changeset List

Diff 46203

View Options

web/settings/account-settings.css

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines
View Options

web/settings/account-settings.react.js

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines
View Options

web/settings/password-change-modal.css

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines
View Options

web/settings/password-change-modal.js

Show All 13 Lines
} }
jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) { jsi::Value CommRustModule::generateNonce(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGenerateNonce(currentID); identityGenerateNonce(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 25 Linesjsi::Value CommRustModule::registerUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityRegisterUser( identityRegisterUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 36 Linesjsi::Value CommRustModule::loginPasswordUser(
auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt); auto contentOneTimeKeysRust = jsiStringArrayToRustVec(contentOneTimeKeys, rt);
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginPasswordUser( identityLoginPasswordUser(
usernameRust, usernameRust,
passwordRust, passwordRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 38 Linesjsi::Value CommRustModule::loginWalletUser(
auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt); auto notifOneTimeKeysRust = jsiStringArrayToRustVec(notifOneTimeKeys, rt);
auto socialProofRust = jsiStringToRustString(socialProof, rt); auto socialProofRust = jsiStringToRustString(socialProof, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityLoginWalletUser( identityLoginWalletUser(
siweMessageRust, siweMessageRust,
siweSignatureRust, siweSignatureRust,
keyPayloadRust, keyPayloadRust,
keyPayloadSignatureRust, keyPayloadSignatureRust,
contentPrekeyRust, contentPrekeyRust,
contentPrekeySignatureRust, contentPrekeySignatureRust,
notifPrekeyRust, notifPrekeyRust,
Show All 23 Linesjsi::Value CommRustModule::updatePassword(
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
auto passwordRust = jsiStringToRustString(password, rt); auto passwordRust = jsiStringToRustString(password, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUpdateUserPassword( identityUpdateUserPassword(
userIDRust, userIDRust,
deviceIDRust, deviceIDRust,
accessTokenRust, accessTokenRust,
passwordRust, passwordRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 14 Linesjsi::Value CommRustModule::deleteUser(
auto deviceIDRust = jsiStringToRustString(deviceID, rt); auto deviceIDRust = jsiStringToRustString(deviceID, rt);
auto accessTokenRust = jsiStringToRustString(accessToken, rt); auto accessTokenRust = jsiStringToRustString(accessToken, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityDeleteUser( identityDeleteUser(
userIDRust, deviceIDRust, accessTokenRust, currentID); userIDRust, deviceIDRust, accessTokenRust, currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
Show All 12 Linesjsi::Value CommRustModule::getOutboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetOutboundKeysForUser( identityGetOutboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 16 Linesjsi::Value CommRustModule::getInboundKeysForUser(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto userIDRust = jsiStringToRustString(userID, rt); auto userIDRust = jsiStringToRustString(userID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetInboundKeysForUser( identityGetInboundKeysForUser(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
userIDRust, userIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
}); });
} }
jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) { jsi::Value CommRustModule::versionSupported(jsi::Runtime &rt) {
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityVersionSupported(currentID); identityVersionSupported(currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
}; };
if (!error.empty()) { if (!error.empty()) {
this->jsInvoker_->invokeAsync( this->jsInvoker_->invokeAsync(
[error, promise]() { promise->reject(error); }); [error, promise]() { promise->reject(error); });
} }
Show All 15 Linesjsi::Value CommRustModule::uploadOneTimeKeys(
auto notifOneTimePreKeysRust = auto notifOneTimePreKeysRust =
jsiStringArrayToRustVec(notifOneTimePreKeys, rt); jsiStringArrayToRustVec(notifOneTimePreKeys, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityUploadOneTimeKeys( identityUploadOneTimeKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
contentOneTimePreKeysRust, contentOneTimePreKeysRust,
notifOneTimePreKeysRust, notifOneTimePreKeysRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
Show All 17 Linesjsi::Value CommRustModule::getKeyserverKeys(
auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt); auto authAccessTokenRust = jsiStringToRustString(authAccessToken, rt);
auto keyserverIDRust = jsiStringToRustString(keyserverID, rt); auto keyserverIDRust = jsiStringToRustString(keyserverID, rt);
return createPromiseAsJSIValue( return createPromiseAsJSIValue(
rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) { rt, [=, this](jsi::Runtime &innerRt, std::shared_ptr<Promise> promise) {
std::string error; std::string error;
try { try {
auto currentID = RustPromiseManager::instance.addPromise( auto currentID = RustPromiseManager::instance.addPromise(
promise, this->jsInvoker_, innerRt); {promise, this->jsInvoker_, innerRt});
identityGetKeyserverKeys( identityGetKeyserverKeys(
authUserIDRust, authUserIDRust,
authDeviceIDRust, authDeviceIDRust,
authAccessTokenRust, authAccessTokenRust,
keyserverIDRust, keyserverIDRust,
currentID); currentID);
} catch (const std::exception &e) { } catch (const std::exception &e) {
error = e.what(); error = e.what();
Show All 9 Lines