andreacavalli/tdlib-fork
Archived
1
0
Fork 0
Code Pull Requests Releases Activity

Update language pack API.

Browse Source 
GitOrigin-RevId: 252723bc424afb8e0eb3c1647198e302b23e10db
This commit is contained in:
levlam 2018-09-04 04:29:26 +03:00
parent 20d1e6902d
commit ad26781fbc
8 changed files with 166 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
td/generate/scheme/td_api.tl
View File

@ -1703,16 +1703,16 @@ chatEvents events:vector<chatEvent> = ChatEvents;
chatEventLogFilters message_edits:Bool message_deletions:Bool message_pins:Bool member_joins:Bool member_leaves:Bool member_invites:Bool member_promotions:Bool member_restrictions:Bool info_changes:Bool setting_changes:Bool = ChatEventLogFilters;
//@class LanguagePackStringValue @description Represents a value of language pack string
//@class LanguagePackStringValue @description Represents the value of a string in a language pack
//@description An ordinary language pack string @value String value
languagePackStringValueOrdinary value:string = LanguagePackStringValue;
//@description A language pack string, which has different forms based on some quantity @zero_value Value for zero objects @one_value Value for one object @two_value Value for two objects
//@description A language pack string which has different forms based on the number of some object it mentions @zero_value Value for zero objects @one_value Value for one object @two_value Value for two objects
//@few_value Value for few objects @many_value Value for many objects @other_value Default value
languagePackStringValuePluralized zero_value:string one_value:string two_value:string few_value:string many_value:string other_value:string = LanguagePackStringValue;
//@description A deleted language pack string, the value should be taken from a built-in english language pack
//@description A deleted language pack string, the value should be taken from the built-in english language pack
languagePackStringValueDeleted = LanguagePackStringValue;
@ -1722,11 +1722,11 @@ languagePackString key:string value:LanguagePackStringValue = LanguagePackString
//@description Contains a list of language pack strings @strings A list of language pack strings
languagePackStrings strings:vector<languagePackString> = LanguagePackStrings;
//@description Contains information about a language @code Language code @name Language name @native_name Language native name @local_string_count Total number of locally available non-deleted strings from the language
languageInfo code:string name:string native_name:string local_string_count:int32 = LanguageInfo;
//@description Contains information about a language pack @id Unique language pack identifier @name Language name @native_name Name of the language in that language @local_string_count Total number of non-deleted strings from the language pack available locally
languagePackInfo id:string name:string native_name:string local_string_count:int32 = LanguagePackInfo;
//@description Contains information about a language pack @languages List of available languages
languagePack languages:vector<languageInfo> = LanguagePack;
//@description Contains information about the current localization target @language_packs List of available language packs for this application
localizationTargetInfo language_packs:vector<languagePackInfo> = LocalizationTargetInfo;
//@class DeviceToken @description Represents a data needed to subscribe for push notifications. To use specific push notification service, you must specify the correct application platform and upload valid server authentication data at https://my.telegram.org
@ -2270,8 +2270,8 @@ updateFavoriteStickers sticker_ids:vector<int32> = Update;
//@description The list of saved animations was updated @animation_ids The new list of file identifiers of saved animations
updateSavedAnimations animation_ids:vector<int32> = Update;
//@description Some language pack strings was updated @language_pack Changed language pack @language_code Code of the language, which was updated @strings List of changed language pack strings
updateLanguagePackStrings language_pack:string language_code:string strings:vector<languagePackString> = Update;
//@description Some language pack strings have been updated @localization_target Localization target to which the language pack belongs @language_pack_id Identifier of the updated language pack @strings List of changed language pack strings
updateLanguagePackStrings localization_target:string language_pack_id:string strings:vector<languagePackString> = Update;
//@description The connection state has changed @state The new connection state
updateConnectionState state:ConnectionState = Update;
@ -2648,8 +2648,9 @@ getFileExtension mime_type:string = Text;
//@description Removes potentially dangerous characters from the name of a file. The encoding of the file name is supposed to be UTF-8. Returns an empty string on failure. This is an offline method. Can be called before authorization. Can be called synchronously @file_name File name or path to the file
cleanFileName file_name:string = Text;
//@description Returns a string stored in a local database from specified language pack and language by its key. Returns a 404 error if the string is not found. This is an offline method. Can be called before authorization. Can be called synchronously @language_database_path Path to a language database in which strings are stored @language_pack Language pack of string to return @language_code Language code of string to return @key Language pack key of string to return
getLanguagePackString language_database_path:string language_pack:string language_code:string key:string = LanguagePackStringValue;
//@description Returns a string stored in the local database from the specified localization target and language pack by its key. Returns a 404 error if the string is not found. This is an offline method. Can be called before authorization. Can be called synchronously
//@language_pack_database_path Path to the language pack database in which strings are stored @localization_target Localization target to which the language pack belongs @language_pack_id Language pack identifier @key Language pack key of the string to be returned
getLanguagePackString language_pack_database_path:string localization_target:string language_pack_id:string key:string = LanguagePackStringValue;
//@description Sends an inline query to a bot and returns its results. Returns an error with code 502 if the bot fails to answer the query before the query timeout expires @bot_user_id The identifier of the target bot
@ -3130,23 +3131,23 @@ getSupportUser = User;
getWallpapers = Wallpapers;
//@description Returns information about the used language pack
getLanguagePackInfo = LanguagePack;
//@description Returns information about the current localization target
getLocalizationTargetInfo = LocalizationTargetInfo;
//@description Returns strings from a language in the used language pack by their keys @language_code Language code of strings to return @keys Language pack keys of strings to return; may be empty to get all available strings
getLanguagePackStrings language_code:string keys:vector<string> = LanguagePackStrings;
//@description Returns strings from a language pack in the current localization target by their keys @language_pack_id Language pack identifier of the strings to be returned @keys Language pack keys of the strings to be returned; leave empty to request all available strings
getLanguagePackStrings language_pack_id:string keys:vector<string> = LanguagePackStrings;
//@description Adds or changes a custom language to the used language pack @info Information about the language. Language code must start with 'X', consist only of English letters, digits and hyphens and be not longer than 64 characters @strings New language pack strings
setCustomLanguage info:languageInfo strings:vector<languagePackString> = Ok;
//@description Adds or changes a custom language pack to the current localization target @info Information about the language pack. Language pack ID must start with 'X', consist only of English letters, digits and hyphens, and must not exceed 64 characters @strings Strings of the new language pack
setCustomLanguagePack info:languagePackInfo strings:vector<languagePackString> = Ok;
//@description Edits informatioan about a custom language @info New information about the custom language
editCustomLanguageInfo info:languageInfo = Ok;
//@description Edits information about a custom language pack in the current localization target @info New information about the custom language pack
editCustomLanguagePackInfo info:languagePackInfo = Ok;
//@description Sets new value for a string in a custom language in the used language pack @language_code The code of previously added custom language, must start with 'X' @new_string New language pack string
setCustomLanguageString language_code:string new_string:languagePackString = Ok;
//@description Adds, edits or deletes a string in a custom language pack @language_pack_id Identifier of a previously added custom language pack in the current localization target @new_string New language pack string
setCustomLanguagePackString language_pack_id:string new_string:languagePackString = Ok;
//@description Deletes all information about a language in the used language pack. Currently used language can't be deleted @language_code Language code of a language to delete
deleteLanguage language_code:string = Ok;
//@description Deletes all information about a language pack in the current localization target. The language pack that is currently in use can't be deleted @language_pack_id Identifier of the language pack to delete
deleteLanguagePack language_pack_id:string = Ok;
//@description Registers the currently used device for receiving push notifications @device_token Device token @other_user_ids List of at most 100 user identifiers of other users currently using the client

BIN
td/generate/scheme/td_api.tlo
View File

Binary file not shown.

13
td/telegram/ConfigManager.cpp
View File

@ -804,16 +804,16 @@ void ConfigManager::process_config(tl_object_ptr<telegram_api::config> config) {
if (is_from_main_dc) {
shared_config.set_option_integer("webfile_dc_id", config->webfile_dc_id_);
if ((config->flags_ & telegram_api::config::TMP_SESSIONS_MASK) != 0) {
G()->shared_config().set_option_integer("session_count", config->tmp_sessions_);
shared_config.set_option_integer("session_count", config->tmp_sessions_);
} else {
G()->shared_config().set_option_empty("session_count");
shared_config.set_option_empty("session_count");
}
if ((config->flags_ & telegram_api::config::SUGGESTED_LANG_CODE_MASK) != 0) {
G()->shared_config().set_option_string("suggested_language_code", config->suggested_lang_code_);
G()->shared_config().set_option_integer("language_pack_version", config->lang_pack_version_);
shared_config.set_option_string("suggested_language_pack_id", config->suggested_lang_code_);
shared_config.set_option_integer("language_pack_version", config->lang_pack_version_);
} else {
G()->shared_config().set_option_empty("suggested_language_code");
G()->shared_config().set_option_empty("language_pack_version");
shared_config.set_option_empty("suggested_language_pack_id");
shared_config.set_option_empty("language_pack_version");
}
}
@ -853,6 +853,7 @@ void ConfigManager::process_config(tl_object_ptr<telegram_api::config> config) {
}
// delete outdated options
shared_config.set_option_empty("suggested_language_code");
shared_config.set_option_empty("chat_big_size");
shared_config.set_option_empty("group_size_max");
shared_config.set_option_empty("saved_gifs_limit");

140
td/telegram/LanguagePackManager.cpp
View File

@ -130,7 +130,7 @@ static int32 load_database_language_key_count(SqliteKeyValue *kv) {
for (auto &str : kv->get_all()) {
key_count += str.first[0] != '!' && (str.second[0] == '1' || str.second[0] == '2');
}
LOG(INFO) << "Set language key count in database to " << key_count;
LOG(INFO) << "Set language pack key count in database to " << key_count;
kv->set("!key_count", to_string(key_count));
return key_count;
}
@ -148,7 +148,7 @@ LanguagePackManager::LanguageDatabase *LanguagePackManager::add_language_databas
if (!path.empty()) {
auto r_database = open_database(path);
if (r_database.is_error()) {
LOG(ERROR) << "Can't open language database " << path << ": " << r_database.error();
LOG(ERROR) << "Can't open language pack database " << path << ": " << r_database.error();
return add_language_database(string());
}
@ -164,20 +164,20 @@ LanguagePackManager::LanguageDatabase *LanguagePackManager::add_language_databas
void LanguagePackManager::start_up() {
std::lock_guard<std::mutex> lock(language_database_mutex_);
manager_count_++;
language_pack_ = G()->shared_config().get_option_string("language_pack");
language_code_ = G()->shared_config().get_option_string("language_code");
language_pack_ = G()->shared_config().get_option_string("localization_target");
language_code_ = G()->shared_config().get_option_string("language_pack_id");
CHECK(check_language_pack_name(language_pack_));
CHECK(check_language_code_name(language_code_));
database_ = add_language_database(G()->shared_config().get_option_string("language_database_path"));
database_ = add_language_database(G()->shared_config().get_option_string("language_pack_database_path"));
if (!language_pack_.empty() && !language_code_.empty()) {
auto language = add_language(database_, language_pack_, language_code_);
if (!is_custom_language_code(language_code_) && language->version_ == -1) {
get_language_pack_strings(language_code_, vector<string>(), Auto());
}
LOG(INFO) << "Use language pack \"" << language_pack_ << "\" with language \"" << language_code_ << "\" of version "
<< language->version_.load() << " with database \"" << database_->path_ << '"';
LOG(INFO) << "Use localization target \"" << language_pack_ << "\" with language pack \"" << language_code_
<< "\" of version " << language->version_.load() << " with database \"" << database_->path_ << '"';
}
}
@ -185,14 +185,14 @@ void LanguagePackManager::tear_down() {
std::lock_guard<std::mutex> lock(language_database_mutex_);
manager_count_--;
if (manager_count_ == 0) {
// can't clear language packs, because the may be accessed later using synchronous requests
// can't clear language packs, because they may be accessed later using synchronous requests
// LOG(INFO) << "Clear language packs";
// language_databases_.clear();
}
}
void LanguagePackManager::on_language_pack_changed() {
auto new_language_pack = G()->shared_config().get_option_string("language_pack");
auto new_language_pack = G()->shared_config().get_option_string("localization_target");
if (new_language_pack == language_pack_) {
return;
}
@ -203,7 +203,7 @@ void LanguagePackManager::on_language_pack_changed() {
}
void LanguagePackManager::on_language_code_changed() {
auto new_language_code = G()->shared_config().get_option_string("language_code");
auto new_language_code = G()->shared_config().get_option_string("language_pack_id");
if (new_language_code == language_code_) {
return;
}
@ -248,7 +248,7 @@ void LanguagePackManager::on_language_pack_version_changed(int32 new_version) {
}
auto result = r_result.move_as_ok();
LOG(INFO) << "Receive language pack difference for language " << result->lang_code_ << " from version "
LOG(INFO) << "Receive language pack difference for language pack " << result->lang_code_ << " from version "
<< result->from_version_ << " with version " << result->version_ << " of size "
<< result->strings_.size();
LOG_IF(ERROR, result->lang_code_ != language_code)
@ -264,30 +264,31 @@ void LanguagePackManager::on_language_pack_version_changed(int32 new_version) {
}
void LanguagePackManager::on_update_language_pack(tl_object_ptr<telegram_api::langPackDifference> difference) {
LOG(INFO) << "Receive update language pack difference for language " << difference->lang_code_ << " from version "
<< difference->from_version_ << " with version " << difference->version_ << " of size "
LOG(INFO) << "Receive update language pack difference for language pack " << difference->lang_code_
<< " from version " << difference->from_version_ << " with version " << difference->version_ << " of size "
<< difference->strings_.size();
if (language_pack_.empty()) {
LOG(WARNING) << "Ignore difference for language " << difference->lang_code_ << ", because language pack was unset";
LOG(WARNING) << "Ignore difference for language pack " << difference->lang_code_
<< ", because used language pack was unset";
return;
}
if (difference->lang_code_ != language_code_) {
LOG(WARNING) << "Ignore difference for language " << difference->lang_code_;
LOG(WARNING) << "Ignore difference for language pack " << difference->lang_code_;
return;
}
if (is_custom_language_code(difference->lang_code_) || difference->lang_code_.empty()) {
LOG(ERROR) << "Ignore difference for language " << difference->lang_code_;
LOG(ERROR) << "Ignore difference for language pack " << difference->lang_code_;
return;
}
Language *language = get_language(database_, language_pack_, language_code_);
int32 version = language == nullptr ? static_cast<int32>(-1) : language->version_.load();
if (difference->version_ <= version) {
LOG(INFO) << "Skip applying already applied updates";
LOG(INFO) << "Skip applying already applied language pack updates";
return;
}
if (version == -1 || version < difference->from_version_) {
LOG(INFO) << "Can't apply difference";
LOG(INFO) << "Can't apply language pack difference";
return on_language_pack_version_changed(difference->version_);
}
@ -421,17 +422,17 @@ bool LanguagePackManager::load_language_strings(LanguageDatabase *database, Lang
std::lock_guard<std::mutex> database_lock(database->mutex_);
std::lock_guard<std::mutex> language_lock(language->mutex_);
if (language->is_full_) {
LOG(DEBUG) << "The language is full in memory";
LOG(DEBUG) << "The language pack is already full in memory";
return true;
}
if (language->kv_.empty()) {
LOG(DEBUG) << "The language has no database";
LOG(DEBUG) << "The language pack has no database";
return false;
}
LOG(DEBUG) << "Begin to load a language from database";
LOG(DEBUG) << "Begin to load a language pack from database";
if (keys.empty()) {
if (language->version_ == -1 && language->was_loaded_full_) {
LOG(DEBUG) << "The language has already been loaded";
LOG(DEBUG) << "The language pack has already been loaded";
return false;
}
@ -548,9 +549,9 @@ td_api::object_ptr<td_api::languagePackStrings> LanguagePackManager::get_languag
return td_api::make_object<td_api::languagePackStrings>(std::move(strings));
}
void LanguagePackManager::get_languages(Promise<td_api::object_ptr<td_api::languagePack>> promise) {
void LanguagePackManager::get_languages(Promise<td_api::object_ptr<td_api::localizationTargetInfo>> promise) {
if (language_pack_.empty()) {
return promise.set_error(Status::Error(400, "Option \"language_pack\" needs to be set first"));
return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
}
auto request_promise = PromiseCreator::lambda([actor_id = actor_id(this), language_pack = language_pack_,
@ -569,8 +570,8 @@ void LanguagePackManager::get_languages(Promise<td_api::object_ptr<td_api::langu
void LanguagePackManager::on_get_languages(vector<tl_object_ptr<telegram_api::langPackLanguage>> languages,
string language_pack,
Promise<td_api::object_ptr<td_api::languagePack>> promise) {
auto results = make_tl_object<td_api::languagePack>();
Promise<td_api::object_ptr<td_api::localizationTargetInfo>> promise) {
auto results = td_api::make_object<td_api::localizationTargetInfo>();
{
std::lock_guard<std::mutex> packs_lock(database_->mutex_);
@ -578,24 +579,24 @@ void LanguagePackManager::on_get_languages(vector<tl_object_ptr<telegram_api::la
if (pack_it != database_->language_packs_.end()) {
LanguagePack *pack = pack_it->second.get();
for (auto &info : pack->language_infos_) {
results->languages_.push_back(
make_tl_object<td_api::languageInfo>(info.first, info.second.name, info.second.native_name, 0));
results->language_packs_.push_back(
make_tl_object<td_api::languagePackInfo>(info.first, info.second.name, info.second.native_name, 0));
}
}
}
for (auto &language : languages) {
results->languages_.push_back(
make_tl_object<td_api::languageInfo>(language->lang_code_, language->name_, language->native_name_, 0));
results->language_packs_.push_back(
make_tl_object<td_api::languagePackInfo>(language->lang_code_, language->name_, language->native_name_, 0));
}
for (auto &language_info : results->languages_) {
if (!check_language_code_name(language_info->code_)) {
LOG(ERROR) << "Receive unsupported language code " << language_info->code_ << " from server";
for (auto &language_info : results->language_packs_) {
if (!check_language_code_name(language_info->id_)) {
LOG(ERROR) << "Receive unsupported language pack ID " << language_info->id_ << " from server";
continue;
}
auto language = add_language(database_, language_pack, language_info->code_);
auto language = add_language(database_, language_pack, language_info->id_);
language_info->local_string_count_ = language->key_count_;
}
@ -605,10 +606,10 @@ void LanguagePackManager::on_get_languages(vector<tl_object_ptr<telegram_api::la
void LanguagePackManager::get_language_pack_strings(string language_code, vector<string> keys,
Promise<td_api::object_ptr<td_api::languagePackStrings>> promise) {
if (!check_language_code_name(language_code) || language_code.empty()) {
return promise.set_error(Status::Error(400, "Language code is invalid"));
return promise.set_error(Status::Error(400, "Language pack ID is invalid"));
}
if (language_pack_.empty()) {
return promise.set_error(Status::Error(400, "Option \"language_pack\" needs to be set first"));
return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
}
for (auto &key : keys) {
if (!is_valid_key(key)) {
@ -651,12 +652,11 @@ void LanguagePackManager::get_language_pack_strings(string language_code, vector
}
auto result = r_result.move_as_ok();
LOG(INFO) << "Receive language pack for language " << result->lang_code_ << " from version "
<< result->from_version_ << " with version " << result->version_ << " of size "
<< result->strings_.size();
LOG(INFO) << "Receive language pack " << result->lang_code_ << " from version " << result->from_version_
<< " with version " << result->version_ << " of size " << result->strings_.size();
LOG_IF(ERROR, result->lang_code_ != language_code)
<< "Receive strings for " << result->lang_code_ << " instead of " << language_code;
LOG_IF(ERROR, result->from_version_ != 0) << "Receive lang pack from version " << result->from_version_;
LOG_IF(ERROR, result->from_version_ != 0) << "Receive language pack from version " << result->from_version_;
send_closure(actor_id, &LanguagePackManager::on_get_language_pack_strings, std::move(language_pack),
std::move(language_code), result->version_, false, vector<string>(), std::move(result->strings_),
std::move(promise));
@ -731,10 +731,10 @@ void LanguagePackManager::on_get_all_language_pack_strings(
for (auto &promise : promises) {
if (promise) {
if (left_non_empty_promise_count == 1) {
LOG(INFO) << "Set last non-empty promise";
LOG(DEBUG) << "Set last non-empty promise";
promise.set_value(std::move(strings));
} else {
LOG(INFO) << "Set non-empty promise";
LOG(DEBUG) << "Set non-empty promise";
vector<td_api::object_ptr<td_api::languagePackString>> strings_copy;
for (auto &result : strings->strings_) {
CHECK(result != nullptr);
@ -745,7 +745,7 @@ void LanguagePackManager::on_get_all_language_pack_strings(
}
left_non_empty_promise_count--;
} else {
LOG(INFO) << "Set empty promise";
LOG(DEBUG) << "Set empty promise";
promise.set_value(nullptr);
}
}
@ -757,10 +757,10 @@ td_api::object_ptr<td_api::Object> LanguagePackManager::get_language_pack_string
const string &language_code,
const string &key) {
if (!check_language_pack_name(language_pack) || language_pack.empty()) {
return td_api::make_object<td_api::error>(400, "Language pack is invalid");
return td_api::make_object<td_api::error>(400, "Localization target is invalid");
}
if (!check_language_code_name(language_code) || language_code.empty()) {
return td_api::make_object<td_api::error>(400, "Language code is invalid");
return td_api::make_object<td_api::error>(400, "Language pack ID is invalid");
}
if (!is_valid_key(key)) {
return td_api::make_object<td_api::error>(400, "Key is invalid");
@ -795,7 +795,7 @@ bool LanguagePackManager::is_valid_key(Slice key) {
void LanguagePackManager::save_strings_to_database(SqliteKeyValue *kv, int32 new_version, bool new_is_full,
int32 new_key_count, vector<std::pair<string, string>> strings) {
LOG(DEBUG) << "Save to database a language with new version " << new_version << " and " << strings.size()
LOG(DEBUG) << "Save to database a language pack with new version " << new_version << " and " << strings.size()
<< " new strings";
if (new_version == -1 && strings.empty()) {
return;
@ -809,7 +809,7 @@ void LanguagePackManager::save_strings_to_database(SqliteKeyValue *kv, int32 new
}
auto old_version = load_database_language_version(kv);
if (old_version > new_version || (old_version == new_version && strings.empty())) {
LOG(DEBUG) << "Language version doesn't increased from " << old_version;
LOG(DEBUG) << "Language pack version doesn't increased from " << old_version;
return;
}
@ -825,14 +825,14 @@ void LanguagePackManager::save_strings_to_database(SqliteKeyValue *kv, int32 new
} else {
kv->set(str.first, str.second);
}
LOG(DEBUG) << "Save language string with key " << str.first << " to database";
LOG(DEBUG) << "Save language pack string with key " << str.first << " to database";
}
if (old_version != new_version) {
LOG(DEBUG) << "Set language version in database to " << new_version;
LOG(DEBUG) << "Set language pack version in database to " << new_version;
kv->set("!version", to_string(new_version));
}
if (new_key_count != -1) {
LOG(DEBUG) << "Set language key count in database to " << new_key_count;
LOG(DEBUG) << "Set language pack key count in database to " << new_key_count;
kv->set("!key_count", to_string(new_key_count));
}
kv->commit_transaction().ensure();
@ -860,7 +860,7 @@ void LanguagePackManager::on_get_language_pack_strings(
if (language->version_ < version || !keys.empty()) {
vector<td_api::object_ptr<td_api::languagePackString>> strings;
if (language->version_ < version && !(is_diff && language->version_ == -1)) {
LOG(INFO) << "Set language " << language_code << " version to " << version;
LOG(INFO) << "Set language pack " << language_code << " version to " << version;
language->version_ = version;
new_database_version = version;
is_version_changed = true;
@ -996,7 +996,7 @@ void LanguagePackManager::on_failed_get_difference(string language_pack, string
Result<tl_object_ptr<telegram_api::LangPackString>> LanguagePackManager::convert_to_telegram_api(
tl_object_ptr<td_api::languagePackString> &&str) {
if (str == nullptr) {
return Status::Error(400, "Language strings must not be null");
return Status::Error(400, "Language pack strings must not be null");
}
string key = std::move(str->key_);
@ -1011,7 +1011,7 @@ Result<tl_object_ptr<telegram_api::LangPackString>> LanguagePackManager::convert
case td_api::languagePackStringValueOrdinary::ID: {
auto value = static_cast<td_api::languagePackStringValueOrdinary *>(str->value_.get());
if (!clean_input_string(value->value_)) {
return Status::Error(400, "Strings must be encoded in UTF-8");
return Status::Error(400, "Language pack string value must be encoded in UTF-8");
}
return make_tl_object<telegram_api::langPackString>(std::move(key), std::move(value->value_));
}
@ -1020,7 +1020,7 @@ Result<tl_object_ptr<telegram_api::LangPackString>> LanguagePackManager::convert
if (!clean_input_string(value->zero_value_) || !clean_input_string(value->one_value_) ||
!clean_input_string(value->two_value_) || !clean_input_string(value->few_value_) ||
!clean_input_string(value->many_value_) || !clean_input_string(value->other_value_)) {
return Status::Error(400, "Strings must be encoded in UTF-8");
return Status::Error(400, "Language pack string value must be encoded in UTF-8");
}
return make_tl_object<telegram_api::langPackStringPluralized>(
31, std::move(key), std::move(value->zero_value_), std::move(value->one_value_), std::move(value->two_value_),
@ -1039,13 +1039,13 @@ void LanguagePackManager::set_custom_language(string language_code, string langu
vector<tl_object_ptr<td_api::languagePackString>> strings,
Promise<Unit> &&promise) {
if (language_pack_.empty()) {
return promise.set_error(Status::Error(400, "Option \"language_pack\" needs to be set first"));
return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
}
if (!check_language_code_name(language_code)) {
return promise.set_error(Status::Error(400, "Language code name must contain only letters and hyphen"));
return promise.set_error(Status::Error(400, "Language pack ID must contain only letters, digits and hyphen"));
}
if (!is_custom_language_code(language_code)) {
return promise.set_error(Status::Error(400, "Custom language code must begin with 'X'"));
return promise.set_error(Status::Error(400, "Custom language pack ID must begin with 'X'"));
}
vector<tl_object_ptr<telegram_api::LangPackString>> server_strings;
@ -1078,13 +1078,13 @@ void LanguagePackManager::set_custom_language(string language_code, string langu
void LanguagePackManager::edit_custom_language_info(string language_code, string language_name,
string language_native_name, Promise<Unit> &&promise) {
if (language_pack_.empty()) {
return promise.set_error(Status::Error(400, "Option \"language_pack\" needs to be set first"));
return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
}
if (!check_language_code_name(language_code)) {
return promise.set_error(Status::Error(400, "Language code name must contain only letters and hyphen"));
return promise.set_error(Status::Error(400, "Language pack ID must contain only letters, digits and hyphen"));
}
if (!is_custom_language_code(language_code)) {
return promise.set_error(Status::Error(400, "Custom language code must begin with 'X'"));
return promise.set_error(Status::Error(400, "Custom language pack ID must begin with 'X'"));
}
std::lock_guard<std::mutex> packs_lock(database_->mutex_);
@ -1109,20 +1109,20 @@ void LanguagePackManager::set_custom_language_string(string language_code,
tl_object_ptr<td_api::languagePackString> str,
Promise<Unit> &&promise) {
if (language_pack_.empty()) {
return promise.set_error(Status::Error(400, "Option \"language_pack\" needs to be set first"));
return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
}
if (!check_language_code_name(language_code)) {
return promise.set_error(Status::Error(400, "Language code name must contain only letters and hyphen"));
return promise.set_error(Status::Error(400, "Language pack ID must contain only letters, digits and hyphen"));
}
if (!is_custom_language_code(language_code)) {
return promise.set_error(Status::Error(400, "Custom language code must begin with 'X'"));
return promise.set_error(Status::Error(400, "Custom language pack ID must begin with 'X'"));
}
if (get_language(database_, language_pack_, language_code) == nullptr) {
return promise.set_error(Status::Error(400, "Custom language not found"));
return promise.set_error(Status::Error(400, "Custom language pack not found"));
}
if (str == nullptr) {
return promise.set_error(Status::Error(400, "Language strings must not be null"));
return promise.set_error(Status::Error(400, "Language pack strings must not be null"));
}
vector<string> keys{str->key_};
@ -1142,16 +1142,16 @@ void LanguagePackManager::set_custom_language_string(string language_code,
void LanguagePackManager::delete_language(string language_code, Promise<Unit> &&promise) {
if (language_pack_.empty()) {
return promise.set_error(Status::Error(400, "Option \"language_pack\" needs to be set first"));
return promise.set_error(Status::Error(400, "Option \"localization_target\" needs to be set first"));
}
if (!check_language_code_name(language_code)) {
return promise.set_error(Status::Error(400, "Language code name is invalid"));
return promise.set_error(Status::Error(400, "Language pack ID is invalid"));
}
if (language_code.empty()) {
return promise.set_error(Status::Error(400, "Language code name is empty"));
return promise.set_error(Status::Error(400, "Language pack ID is empty"));
}
if (language_code_ == language_code) {
return promise.set_error(Status::Error(400, "Currently used language can't be deleted"));
return promise.set_error(Status::Error(400, "Currently used language pack can't be deleted"));
}
auto status = do_delete_language(language_code);
@ -1175,7 +1175,7 @@ Status LanguagePackManager::do_delete_language(string language_code) {
CHECK(code_it != pack->languages_.end());
auto language = code_it->second.get();
if (language->has_get_difference_query_) {
return Status::Error(400, "Language can't be deleted now, try again later");
return Status::Error(400, "Language pack can't be deleted now, try again later");
}
if (!language->kv_.empty()) {
language->kv_.drop().ignore();

4
td/telegram/LanguagePackManager.h
View File

@ -48,7 +48,7 @@ class LanguagePackManager : public NetQueryCallback {
void on_language_pack_version_changed(int32 new_version);
void get_languages(Promise<td_api::object_ptr<td_api::languagePack>> promise);
void get_languages(Promise<td_api::object_ptr<td_api::localizationTargetInfo>> promise);
void get_language_pack_strings(string language_code, vector<string> keys,
Promise<td_api::object_ptr<td_api::languagePackStrings>> promise);
@ -147,7 +147,7 @@ class LanguagePackManager : public NetQueryCallback {
void on_failed_get_difference(string language_pack, string language_code);
void on_get_languages(vector<tl_object_ptr<telegram_api::langPackLanguage>> languages, string language_pack,
Promise<td_api::object_ptr<td_api::languagePack>> promise);
Promise<td_api::object_ptr<td_api::localizationTargetInfo>> promise);
Status do_delete_language(string language_code);

77
td/telegram/Td.cpp
View File

@ -3265,12 +3265,12 @@ bool Td::is_preinitialization_request(int32 id) {
bool Td::is_preauthentication_request(int32 id) {
switch (id) {
case td_api::processDcUpdate::ID:
case td_api::getLanguagePackInfo::ID:
case td_api::getLocalizationTargetInfo::ID:
case td_api::getLanguagePackStrings::ID:
case td_api::setCustomLanguage::ID:
case td_api::editCustomLanguageInfo::ID:
case td_api::setCustomLanguageString::ID:
case td_api::deleteLanguage::ID:
case td_api::setCustomLanguagePack::ID:
case td_api::editCustomLanguagePackInfo::ID:
case td_api::setCustomLanguagePackString::ID:
case td_api::deleteLanguagePack::ID:
case td_api::getOption::ID:
case td_api::setOption::ID:
case td_api::setNetworkType::ID:
@ -3541,12 +3541,12 @@ void Td::on_config_option_updated(const string &name) {
if (G()->mtproto_header().set_is_emulator(G()->shared_config().get_option_boolean(name))) {
G()->net_query_dispatcher().update_mtproto_header();
}
} else if (name == "language_pack") {
} else if (name == "localization_target") {
send_closure(language_pack_manager_, &LanguagePackManager::on_language_pack_changed);
if (G()->mtproto_header().set_language_pack(G()->shared_config().get_option_string(name))) {
G()->net_query_dispatcher().update_mtproto_header();
}
} else if (name == "language_code") {
} else if (name == "language_pack_id") {
send_closure(language_pack_manager_, &LanguagePackManager::on_language_code_changed);
if (G()->mtproto_header().set_language_code(G()->shared_config().get_option_string(name))) {
G()->net_query_dispatcher().update_mtproto_header();
@ -4020,6 +4020,21 @@ Status Td::init(DbKey key) {
config_manager_ = create_actor<ConfigManager>("ConfigManager", create_reference());
G()->set_config_manager(config_manager_.get());
if (G()->shared_config().have_option("language_database_path")) {
G()->shared_config().set_option_string("language_pack_database_path",
G()->shared_config().get_option_string("language_database_path"));
G()->shared_config().set_option_empty("language_database_path");
}
if (G()->shared_config().have_option("language_pack")) {
G()->shared_config().set_option_string("localization_target",
G()->shared_config().get_option_string("language_pack"));
G()->shared_config().set_option_empty("language_pack");
}
if (G()->shared_config().have_option("language_code")) {
G()->shared_config().set_option_string("language_pack_id", G()->shared_config().get_option_string("language_code"));
G()->shared_config().set_option_empty("language_code");
}
complete_pending_preauthentication_requests([](int32 id) {
switch (id) {
case td_api::getOption::ID:
@ -4030,8 +4045,8 @@ Status Td::init(DbKey key) {
}
});
options_.language_pack = G()->shared_config().get_option_string("language_pack");
options_.language_code = G()->shared_config().get_option_string("language_code");
options_.language_pack = G()->shared_config().get_option_string("localization_target");
options_.language_code = G()->shared_config().get_option_string("language_pack_id");
options_.is_emulator = G()->shared_config().get_option_boolean("is_emulator");
// options_.proxy = Proxy();
G()->set_mtproto_header(std::make_unique<MtprotoHeader>(options_));
@ -6024,7 +6039,7 @@ void Td::on_request(uint64 id, const td_api::getMapThumbnailFile &request) {
}
}
void Td::on_request(uint64 id, const td_api::getLanguagePackInfo &request) {
void Td::on_request(uint64 id, const td_api::getLocalizationTargetInfo &request) {
CHECK_IS_USER();
CREATE_REQUEST_PROMISE();
send_closure(language_pack_manager_, &LanguagePackManager::get_languages, std::move(promise));
@ -6032,55 +6047,55 @@ void Td::on_request(uint64 id, const td_api::getLanguagePackInfo &request) {
void Td::on_request(uint64 id, td_api::getLanguagePackStrings &request) {
CHECK_IS_USER();
CLEAN_INPUT_STRING(request.language_code_);
CLEAN_INPUT_STRING(request.language_pack_id_);
for (auto &key : request.keys_) {
CLEAN_INPUT_STRING(key);
}
CREATE_REQUEST_PROMISE();
send_closure(language_pack_manager_, &LanguagePackManager::get_language_pack_strings,
std::move(request.language_code_), std::move(request.keys_), std::move(promise));
std::move(request.language_pack_id_), std::move(request.keys_), std::move(promise));
}
void Td::on_request(uint64 id, td_api::setCustomLanguage &request) {
void Td::on_request(uint64 id, td_api::setCustomLanguagePack &request) {
CHECK_IS_USER();
if (request.info_ == nullptr) {
return send_error_raw(id, 400, "Language info must not be empty");
return send_error_raw(id, 400, "Language pack info must not be empty");
}
CLEAN_INPUT_STRING(request.info_->code_);
CLEAN_INPUT_STRING(request.info_->id_);
CLEAN_INPUT_STRING(request.info_->name_);
CLEAN_INPUT_STRING(request.info_->native_name_);
CREATE_OK_REQUEST_PROMISE();
send_closure(language_pack_manager_, &LanguagePackManager::set_custom_language, std::move(request.info_->code_),
send_closure(language_pack_manager_, &LanguagePackManager::set_custom_language, std::move(request.info_->id_),
std::move(request.info_->name_), std::move(request.info_->native_name_), std::move(request.strings_),
std::move(promise));
}
void Td::on_request(uint64 id, td_api::editCustomLanguageInfo &request) {
void Td::on_request(uint64 id, td_api::editCustomLanguagePackInfo &request) {
CHECK_IS_USER();
if (request.info_ == nullptr) {
return send_error_raw(id, 400, "Language info must not be empty");
return send_error_raw(id, 400, "Language pack info must not be empty");
}
CLEAN_INPUT_STRING(request.info_->code_);
CLEAN_INPUT_STRING(request.info_->id_);
CLEAN_INPUT_STRING(request.info_->name_);
CLEAN_INPUT_STRING(request.info_->native_name_);
CREATE_OK_REQUEST_PROMISE();
send_closure(language_pack_manager_, &LanguagePackManager::edit_custom_language_info, std::move(request.info_->code_),
send_closure(language_pack_manager_, &LanguagePackManager::edit_custom_language_info, std::move(request.info_->id_),
std::move(request.info_->name_), std::move(request.info_->native_name_), std::move(promise));
}
void Td::on_request(uint64 id, td_api::setCustomLanguageString &request) {
void Td::on_request(uint64 id, td_api::setCustomLanguagePackString &request) {
CHECK_IS_USER();
CLEAN_INPUT_STRING(request.language_code_);
CLEAN_INPUT_STRING(request.language_pack_id_);
CREATE_OK_REQUEST_PROMISE();
send_closure(language_pack_manager_, &LanguagePackManager::set_custom_language_string,
std::move(request.language_code_), std::move(request.new_string_), std::move(promise));
std::move(request.language_pack_id_), std::move(request.new_string_), std::move(promise));
}
void Td::on_request(uint64 id, td_api::deleteLanguage &request) {
void Td::on_request(uint64 id, td_api::deleteLanguagePack &request) {
CHECK_IS_USER();
CLEAN_INPUT_STRING(request.language_code_);
CLEAN_INPUT_STRING(request.language_pack_id_);
CREATE_OK_REQUEST_PROMISE();
send_closure(language_pack_manager_, &LanguagePackManager::delete_language, std::move(request.language_code_),
send_closure(language_pack_manager_, &LanguagePackManager::delete_language, std::move(request.language_pack_id_),
std::move(promise));
}
@ -6200,13 +6215,13 @@ void Td::on_request(uint64 id, td_api::setOption &request) {
}
break;
case 'l':
if (set_string_option("language_database_path", [](Slice value) { return true; })) {
if (set_string_option("language_pack_database_path", [](Slice value) { return true; })) {
return;
}
if (set_string_option("language_pack", LanguagePackManager::check_language_pack_name)) {
if (set_string_option("localization_target", LanguagePackManager::check_language_pack_name)) {
return;
}
if (set_string_option("language_code", LanguagePackManager::check_language_code_name)) {
if (set_string_option("language_pack_id", LanguagePackManager::check_language_code_name)) {
return;
}
break;
@ -6778,8 +6793,8 @@ td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::cleanFile
}
td_api::object_ptr<td_api::Object> Td::do_static_request(const td_api::getLanguagePackString &request) {
return LanguagePackManager::get_language_pack_string(request.language_database_path_, request.language_pack_,
request.language_code_, request.key_);
return LanguagePackManager::get_language_pack_string(
request.language_pack_database_path_, request.localization_target_, request.language_pack_id_, request.key_);
}
// test

10
td/telegram/Td.h
View File

@ -763,17 +763,17 @@ class Td final : public NetQueryCallback {
void on_request(uint64 id, const td_api::getMapThumbnailFile &request);
void on_request(uint64 id, const td_api::getLanguagePackInfo &request);
void on_request(uint64 id, const td_api::getLocalizationTargetInfo &request);
void on_request(uint64 id, td_api::getLanguagePackStrings &request);
void on_request(uint64 id, td_api::setCustomLanguage &request);
void on_request(uint64 id, td_api::setCustomLanguagePack &request);
void on_request(uint64 id, td_api::editCustomLanguageInfo &request);
void on_request(uint64 id, td_api::editCustomLanguagePackInfo &request);
void on_request(uint64 id, td_api::setCustomLanguageString &request);
void on_request(uint64 id, td_api::setCustomLanguagePackString &request);
void on_request(uint64 id, td_api::deleteLanguage &request);
void on_request(uint64 id, td_api::deleteLanguagePack &request);
void on_request(uint64 id, td_api::getOption &request);

24
td/telegram/cli.cpp
View File

@ -1750,8 +1750,8 @@ class CliClient final : public Actor {
std::tie(chat_id, message_id) = split(args);
send_request(make_tl_object<td_api::deleteChatReplyMarkup>(as_chat_id(chat_id), as_message_id(message_id)));
} else if (op == "glpi") {
send_request(make_tl_object<td_api::getLanguagePackInfo>());
} else if (op == "glti") {
send_request(make_tl_object<td_api::getLocalizationTargetInfo>());
} else if (op == "glps") {
string language_code;
string keys;
@ -1769,7 +1769,7 @@ class CliClient final : public Actor {
std::tie(language_code, key) = split(args);
send_request(
make_tl_object<td_api::getLanguagePackString>(language_database_path, language_pack, language_code, key));
} else if (op == "scl") {
} else if (op == "sclp") {
string language_code;
string name;
string native_name;
@ -1788,9 +1788,9 @@ class CliClient final : public Actor {
strings.push_back(make_tl_object<td_api::languagePackString>(
"DELETED", make_tl_object<td_api::languagePackStringValueDeleted>()));
send_request(make_tl_object<td_api::setCustomLanguage>(
make_tl_object<td_api::languageInfo>(language_code, name, native_name, 3), std::move(strings)));
} else if (op == "ecli") {
send_request(make_tl_object<td_api::setCustomLanguagePack>(
make_tl_object<td_api::languagePackInfo>(language_code, name, native_name, 3), std::move(strings)));
} else if (op == "eclpi") {
string language_code;
string name;
string native_name;
@ -1798,9 +1798,9 @@ class CliClient final : public Actor {
std::tie(language_code, args) = split(args);
std::tie(name, native_name) = split(args);
send_request(make_tl_object<td_api::editCustomLanguageInfo>(
make_tl_object<td_api::languageInfo>(language_code, name, native_name, 3)));
} else if (op == "sclsv" || op == "sclsp" || op == "sclsd") {
send_request(make_tl_object<td_api::editCustomLanguagePackInfo>(
make_tl_object<td_api::languagePackInfo>(language_code, name, native_name, 3)));
} else if (op == "sclpsv" || op == "sclpsp" || op == "sclpsd") {
string language_code;
string key;
string value;
@ -1818,9 +1818,9 @@ class CliClient final : public Actor {
str->value_ = make_tl_object<td_api::languagePackStringValueDeleted>();
}
send_request(make_tl_object<td_api::setCustomLanguageString>(language_code, std::move(str)));
} else if (op == "dl") {
send_request(make_tl_object<td_api::deleteLanguage>(args));
send_request(make_tl_object<td_api::setCustomLanguagePackString>(language_code, std::move(str)));
} else if (op == "dlp") {
send_request(make_tl_object<td_api::deleteLanguagePack>(args));
} else if (op == "go") {
send_request(make_tl_object<td_api::getOption>(args));
} else if (op == "sob") {