static EPhoneNumberCountrySource
_e_phone_number_cxx_get_country_source (const PhoneNumber &phone_number)
{
g_return_val_if_fail (
phone_number.has_country_code_source (),
E_PHONE_NUMBER_COUNTRY_FROM_DEFAULT);
switch (phone_number.country_code_source ()) {
case PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN:
return E_PHONE_NUMBER_COUNTRY_FROM_FQTN;
case PhoneNumber::FROM_NUMBER_WITH_IDD:
return E_PHONE_NUMBER_COUNTRY_FROM_IDD;
/* FROM_NUMBER_WITHOUT_PLUS_SIGN only is used internally
* by libphonenumber to properly(???) reconstruct raw input
* from PhoneNumberUtil::ParseAndKeepRawInput(). Let's not
* bother our users with that barely understandable and
* almost undocumented implementation detail.
*/
case PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN:
case PhoneNumber::FROM_DEFAULT_COUNTRY:
break;
}
return E_PHONE_NUMBER_COUNTRY_FROM_DEFAULT;
}
PhoneNumber VCardFormatImpl::readTelephoneValue( ContentLine *cl )
{
PhoneNumber p;
TelValue *value = (TelValue *)cl->value();
p.setNumber( QString::fromUtf8( value->asString() ) );
int type = 0;
ParamList params = cl->paramList();
ParamListIterator it( params );
for( ; it.current(); ++it ) {
if ( (*it)->name() == "TYPE" ) {
if ( (*it)->value() == "home" ) type |= PhoneNumber::Home;
else if ( (*it)->value() == "work" ) type |= PhoneNumber::Work;
else if ( (*it)->value() == "msg" ) type |= PhoneNumber::Msg;
else if ( (*it)->value() == "pref" ) type |= PhoneNumber::Pref;
else if ( (*it)->value() == "voice" ) type |= PhoneNumber::Voice;
else if ( (*it)->value() == "fax" ) type |= PhoneNumber::Fax;
else if ( (*it)->value() == "cell" ) type |= PhoneNumber::Cell;
else if ( (*it)->value() == "video" ) type |= PhoneNumber::Video;
else if ( (*it)->value() == "bbs" ) type |= PhoneNumber::Bbs;
else if ( (*it)->value() == "modem" ) type |= PhoneNumber::Modem;
else if ( (*it)->value() == "car" ) type |= PhoneNumber::Car;
else if ( (*it)->value() == "isdn" ) type |= PhoneNumber::Isdn;
else if ( (*it)->value() == "pcs" ) type |= PhoneNumber::Pcs;
else if ( (*it)->value() == "pager" ) type |= PhoneNumber::Pager;
}
}
p.setType( type );
return p;
}
/**
* Serialize a phone number into Portable object format.
*
* @param hOut the serializer to write the object to
* @param phone the phone number to serialize
*/
template<> void serialize<PhoneNumber>(PofWriter::Handle hOut,
const PhoneNumber& phone)
{
hOut->writeInt16(ACCESS_CODE, phone.getAccessCode());
hOut->writeInt16(COUNTRY_CODE, phone.getCountryCode());
hOut->writeInt16(AREA_CODE, phone.getAreaCode());
hOut->writeInt32(LOCAL_NUMBER, phone.getLocalNumber());
}
//======================================================ContainerTest
TEST(ContainerTest, CreateInstancePhoneNumberDB) {
PhoneNumberDB & db = PhoneNumberDB::instance ();
PhoneNumber pn = db.getByID (UniqueKey::ID_NONE, AccessMode::AllowCreation);
EXPECT_NE (pn.getID (), UniqueKey::ID_NONE);
pn.mNumber = "123"; EXPECT_TRUE (pn.isValid ());
db.update (pn); EXPECT_EQ (pn, db.getByID (pn.getID (), AccessMode::Existing));
}
void VCardFormatImpl::addTelephoneValue( VCARD::VCard *v, const PhoneNumber &p )
{
if ( p.number().isEmpty() )
return;
ContentLine cl;
cl.setName(EntityTypeToParamName(EntityTelephone));
cl.setValue(new TelValue( p.number().utf8() ));
ParamList params;
if( p.type() & PhoneNumber::Home ) params.append( new Param( "TYPE", "home" ) );
if( p.type() & PhoneNumber::Work ) params.append( new Param( "TYPE", "work" ) );
if( p.type() & PhoneNumber::Msg ) params.append( new Param( "TYPE", "msg" ) );
if( p.type() & PhoneNumber::Pref ) params.append( new Param( "TYPE", "pref" ) );
if( p.type() & PhoneNumber::Voice ) params.append( new Param( "TYPE", "voice" ) );
if( p.type() & PhoneNumber::Fax ) params.append( new Param( "TYPE", "fax" ) );
if( p.type() & PhoneNumber::Cell ) params.append( new Param( "TYPE", "cell" ) );
if( p.type() & PhoneNumber::Video ) params.append( new Param( "TYPE", "video" ) );
if( p.type() & PhoneNumber::Bbs ) params.append( new Param( "TYPE", "bbs" ) );
if( p.type() & PhoneNumber::Modem ) params.append( new Param( "TYPE", "modem" ) );
if( p.type() & PhoneNumber::Car ) params.append( new Param( "TYPE", "car" ) );
if( p.type() & PhoneNumber::Isdn ) params.append( new Param( "TYPE", "isdn" ) );
if( p.type() & PhoneNumber::Pcs ) params.append( new Param( "TYPE", "pcs" ) );
if( p.type() & PhoneNumber::Pager ) params.append( new Param( "TYPE", "pager" ) );
cl.setParamList( params );
v->add(cl);
}
void PhoneNumberDB::
update ( PhoneNumber const & inst, AccessMode mode) {
if ( ! inst.isValid () )
throw BadInstanceException (toStr (inst));
tCIt it = gDB.find (inst.getID ());
if ( (it == gDB.end ()) && (mode != AccessMode::AllowCreation) )
throw NonExistingException (toStr (inst));
gDB [inst.getID ()] = inst;
}
PhoneNumber const PhoneNumberDB::
getByID ( PhoneNumber::tID const & id, AccessMode mode) {
tCIt it = gDB.find (id);
if ( it != gDB.end () )
return it->second;
if ( mode != AccessMode::AllowCreation )
throw NonExistingException ("Account id " + id);
PhoneNumber result (id, AnsiString ());
gDB [result.getID ()] = result;
return result;
}
int main() {
int place = 3;
Array array;
array.addNumber(PhoneNumber(123,456,7890, "Home")); //adds number to array
array.addNumber(PhoneNumber(324,238,0277, "Work"));
array.addNumber(PhoneNumber(111,111,1111));
array.setNumber(PhoneNumber(567,892, 2367, "HOME"), 3); //sets number
cout << "Size is " << array.getSize() << endl; //prints out number of elements added to array
array.print(); //prints elements of array
PhoneNumber uno = array.getNumber(place); //gets the 3rd entry
cout << "New Number is in place " << place << " is ";
uno.print();
return 0;
}
AnsiString const csvLineCDR (Account const &account, PhoneNumber const &phoneNumber, TimePoint const &start, Duration const &duration) {
AnsiString delim = ",";
AnsiString result;
(result += toStr (account.getID ())) += delim;
(result += toStr (phoneNumber.getID ())) += delim;
(result += asTime_t (start)) += delim;
result += asTime_t (duration);
return result;
}
static ERL_NIF_TERM enif_make_phonenumber(ErlNifEnv* env, PhoneNumber phoneNumber){
unsigned char *buffer;
ERL_NIF_TERM raw_input;
ERL_NIF_TERM extension;
ERL_NIF_TERM preferred_domestic_carrier_code;
ERL_NIF_TERM record = enif_make_atom(env, "phonenumber");
// required int32 country_code = 1;
ERL_NIF_TERM has_country_code = enif_make_boolean(env, phoneNumber.has_country_code());
ERL_NIF_TERM country_code = enif_make_int(env, phoneNumber.country_code());
// required uint64 national_number = 2;
ERL_NIF_TERM has_national_number = enif_make_boolean(env, phoneNumber.has_national_number());
ERL_NIF_TERM national_number = enif_make_ulong(env, phoneNumber.national_number());
// optional string extension = 3;
ERL_NIF_TERM has_extension = enif_make_boolean(env, phoneNumber.has_extension());
buffer = enif_make_new_binary(env, phoneNumber.extension().size(), &extension);
std::copy(phoneNumber.extension().begin(), phoneNumber.extension().end(), buffer);
// optional bool italian_leading_zero = 4;
ERL_NIF_TERM has_italian_leading_zero = enif_make_boolean(env, phoneNumber.has_italian_leading_zero());
ERL_NIF_TERM italian_leading_zero = enif_make_boolean(env, phoneNumber.italian_leading_zero());
// optional int32 number_of_leading_zeros = 8 [default = 1];
ERL_NIF_TERM has_number_of_leading_zeros = enif_make_boolean(env, phoneNumber.has_number_of_leading_zeros());
ERL_NIF_TERM number_of_leading_zeros = enif_make_int(env, phoneNumber.number_of_leading_zeros());
// optional string raw_input = 5;
ERL_NIF_TERM has_raw_input = enif_make_boolean(env, phoneNumber.has_raw_input());
buffer = enif_make_new_binary(env, phoneNumber.raw_input().size(), &raw_input);
std::copy(phoneNumber.raw_input().begin(), phoneNumber.raw_input().end(), buffer);
// optional .i18n.phonenumbers.PhoneNumber.CountryCodeSource country_code_source = 6;
ERL_NIF_TERM has_country_code_source = enif_make_boolean(env, phoneNumber.has_country_code_source());
ERL_NIF_TERM country_code_source = enif_make_phonenumber_country_code_source(env, phoneNumber.country_code_source());
// optional string preferred_domestic_carrier_code = 7;
ERL_NIF_TERM has_preferred_domestic_carrier_code = enif_make_boolean(env, phoneNumber.has_preferred_domestic_carrier_code());
buffer = enif_make_new_binary(env, phoneNumber.preferred_domestic_carrier_code().size(), &preferred_domestic_carrier_code);
std::copy(phoneNumber.preferred_domestic_carrier_code().begin(), phoneNumber.preferred_domestic_carrier_code().end(), buffer);
return enif_make_tuple(env, 17,
record,
has_country_code,
country_code,
has_national_number,
national_number,
has_extension,
extension,
has_number_of_leading_zeros,
number_of_leading_zeros,
has_italian_leading_zero,
italian_leading_zero,
has_raw_input,
raw_input,
has_country_code_source,
country_code_source,
has_preferred_domestic_carrier_code,
preferred_domestic_carrier_code
);
}
v8::Handle<v8::Value> Contacts::list(const v8::Arguments& args) {
AppLogTag("Contacts", "Entered Contacts::list (args length:%d)", args.Length());
v8::HandleScope scope;
AddressbookManager* pAddressbookManager = AddressbookManager::GetInstance();
IList* pCategoryList = pAddressbookManager->GetAllCategoriesN();
AppLogTag("Contacts", "TEST1");
Category* pCategory = null;
Contact* pContact = null;
AppLogTag("Contacts", "TEST2");
IEnumerator* pCategoryEnum = pCategoryList->GetEnumeratorN();
v8::Local<v8::Object> categoryObject = v8::Object::New();
while (pCategoryEnum->MoveNext() == E_SUCCESS) {
AppLogTag("Contacts", "TEST");
pCategory = static_cast<Category*>(pCategoryEnum->GetCurrent());
char category[STRING_MAX];
IList* pContactList = pAddressbookManager->GetContactsByCategoryN(pCategory->GetRecordId());
IEnumerator* pContactEnum = pContactList->GetEnumeratorN();
v8::Local<v8::Array> personList = v8::Array::New();
AppLogTag("Contacts", "Fetching category: %ls", pCategory->GetName().GetPointer());
int person_cnt = 0;
while (pContactEnum->MoveNext() == E_SUCCESS) {
pContact = static_cast<Contact*>(pContactEnum->GetCurrent());
String fullName = L"", firstName, lastName;
v8::Local<v8::Object> personObject = v8::Object::New();
char buf[STRING_MAX];
pContact->GetValue(CONTACT_PROPERTY_ID_FIRST_NAME, firstName);
pContact->GetValue(CONTACT_PROPERTY_ID_LAST_NAME, lastName);
fullName.Append(firstName);
fullName.Append(L" ");
fullName.Append(lastName);
AppLogTag("Contacts", "Getting person: %ls", fullName.GetPointer());
IList* pPhoneNumberList = pContact->GetValuesN(CONTACT_MPROPERTY_ID_PHONE_NUMBERS);
v8::Local<v8::Array> phoneList = v8::Array::New();
if (pPhoneNumberList != null) {
IEnumerator* pEnum = pPhoneNumberList->GetEnumeratorN();
int number_cnt = 0;
while (pEnum->MoveNext() == E_SUCCESS) {
PhoneNumber* pPhoneNumber = static_cast<PhoneNumber*>(pEnum->GetCurrent());
String number = pPhoneNumber->GetPhoneNumber();
AppLogTag("Contacts", "Getting person's phonenumber: %ls", number.GetPointer());
phoneList->Set(number_cnt++, v8::String::New(Util::toAnsi(buf, number.GetPointer(), STRING_MAX)));
}
delete pEnum;
pPhoneNumberList->RemoveAll(true);
delete pPhoneNumberList;
}
personObject->Set(v8::String::New("name"), v8::String::New(Util::toAnsi(buf, fullName.GetPointer(), STRING_MAX)));
personObject->Set(v8::String::New("phoneNumber"), phoneList);
personList->Set(person_cnt++, personObject);
}
categoryObject->Set(v8::String::New(Util::toAnsi(category, pCategory->GetName(), STRING_MAX)), personList);
delete pContactEnum;
pContactList->RemoveAll(true);
delete pContactList;
}
return scope.Close(categoryObject);
}
//TODO: Is it possible to set additional information?
v8::Handle<v8::Value> Contacts::add(const v8::Arguments& args) {
AppLog("Entered Contacts::addContact (args length:%d)", args.Length());
// if (args.Length() < 1 || Util::isArgumentNull(args[0])) {
if (args.Length() < 1) {
AppLog("Bad parameters");
return v8::ThrowException(v8::String::New("Bad parameters"));
}
v8::HandleScope scope;
String category;
String name;
String number;
v8::Local<v8::Object> obj = args[0]->ToObject();
if(args[0]->IsObject())
{
v8::Local<v8::Value> obj_category = obj->Get(v8::String::New("category"));
if(obj_category->IsString())
{
category = UNWRAP_STRING(obj_category).c_str();
AppLogTag("Contacts","Add Contacts: [Category:%ls]", category.GetPointer());
}
v8::Local<v8::Value> obj_name = obj->Get(v8::String::New("name"));
if(obj_name->IsString())
{
name = UNWRAP_STRING(obj_name).c_str();
AppLogTag("Contacts","Add Contacts: [Name:%ls]", name.GetPointer());
}
}
if(category == null || name == null)
{
AppLogTag("Contacts","Failed to add Contact");
return scope.Close(v8::Boolean::New(false));
}
//CREATE CONTACT
Contact contact;
contact.SetValue(CONTACT_PROPERTY_ID_FIRST_NAME, name);
v8::Local<v8::Value> obj_number = obj->Get(v8::String::New("number"));
if(!obj_number->IsNull() && obj_number->IsString())
{
number = UNWRAP_STRING(obj_number).c_str();
AppLogTag("Contacts","Add Contacts: [Number:%ls]", number.GetPointer());
PhoneNumber phoneNumber;
phoneNumber.SetPhoneNumber(number);
contact.AddPhoneNumber(phoneNumber);
}
AddressbookManager* pAddressbookManager = AddressbookManager::GetInstance();
Addressbook* pAddressbook = pAddressbookManager->GetAddressbookN(DEFAULT_ADDRESSBOOK_ID);
//GET CATEGORIES TO ADD A CONTACT
IList* pCategoryList = pAddressbook->GetAllCategoriesN();
result r = GetLastResult();
if (IsFailed(r)) {
AppLogTag("Contacts", "Failed to get categories: %s", GetErrorMessage(r));
return scope.Close(v8::Boolean::New(false));
}
if (pCategoryList != null && pCategoryList->GetCount() > 0) {
IEnumerator* pCategoryEnum = pCategoryList->GetEnumeratorN();
Category* pCategory = null;
while (pCategoryEnum->MoveNext() == E_SUCCESS) {
pCategory = static_cast<Category*>(pCategoryEnum->GetCurrent());
if (pCategory->GetName().Equals(category)) {
pAddressbook->AddContact(contact);
pAddressbook->AddMemberToCategory(pCategory->GetRecordId(), contact.GetRecordId());
if (IsFailed(GetLastResult())) {
return scope.Close(v8::Boolean::New(false));
} else {
AppLogTag("Contacts", "%d", contact.GetRecordId());
return scope.Close(v8::Boolean::New(true));
}
}
}
}
AppLogTag("Contacts","No Categories");
return scope.Close(v8::Boolean::New(false));
}
Addressee::List VCardTool::parseVCards(const QString &vcard)
{
static const QChar semicolonSep(';');
static const QChar commaSep(',');
QString identifier;
Addressee::List addrList;
const VCard::List vCardList = VCardParser::parseVCards(vcard);
VCard::List::ConstIterator cardIt;
VCard::List::ConstIterator listEnd(vCardList.end());
for(cardIt = vCardList.begin(); cardIt != listEnd; ++cardIt)
{
Addressee addr;
const QStringList idents = (*cardIt).identifiers();
QStringList::ConstIterator identIt;
QStringList::ConstIterator identEnd(idents.end());
for(identIt = idents.begin(); identIt != identEnd; ++identIt)
{
const VCardLine::List lines = (*cardIt).lines((*identIt));
VCardLine::List::ConstIterator lineIt;
// iterate over the lines
for(lineIt = lines.begin(); lineIt != lines.end(); ++lineIt)
{
identifier = (*lineIt).identifier().lower();
// ADR
if(identifier == "adr")
{
Address address;
const QStringList addrParts = splitString(semicolonSep, (*lineIt).value().asString());
if(addrParts.count() > 0)
address.setPostOfficeBox(addrParts[0]);
if(addrParts.count() > 1)
address.setExtended(addrParts[1]);
if(addrParts.count() > 2)
address.setStreet(addrParts[2]);
if(addrParts.count() > 3)
address.setLocality(addrParts[3]);
if(addrParts.count() > 4)
address.setRegion(addrParts[4]);
if(addrParts.count() > 5)
address.setPostalCode(addrParts[5]);
if(addrParts.count() > 6)
address.setCountry(addrParts[6]);
int type = 0;
const QStringList types = (*lineIt).parameters("type");
for(QStringList::ConstIterator it = types.begin(); it != types.end(); ++it)
type += mAddressTypeMap[(*it).lower()];
address.setType(type);
addr.insertAddress(address);
}
// AGENT
else if(identifier == "agent")
addr.setAgent(parseAgent(*lineIt));
// BDAY
else if(identifier == "bday")
addr.setBirthday(parseDateTime((*lineIt).value().asString()));
// CATEGORIES
else if(identifier == "categories")
{
const QStringList categories = splitString(commaSep, (*lineIt).value().asString());
addr.setCategories(categories);
}
// CLASS
else if(identifier == "class")
addr.setSecrecy(parseSecrecy(*lineIt));
// EMAIL
else if(identifier == "email")
{
const QStringList types = (*lineIt).parameters("type");
addr.insertEmail((*lineIt).value().asString(), types.findIndex("PREF") != -1);
}
// FN
else if(identifier == "fn")
addr.setFormattedName((*lineIt).value().asString());
// GEO
else if(identifier == "geo")
{
Geo geo;
const QStringList geoParts = QStringList::split(';', (*lineIt).value().asString(), true);
geo.setLatitude(geoParts[0].toFloat());
geo.setLongitude(geoParts[1].toFloat());
addr.setGeo(geo);
}
// KEY
else if(identifier == "key")
addr.insertKey(parseKey(*lineIt));
// LABEL
else if(identifier == "label")
{
int type = 0;
const QStringList types = (*lineIt).parameters("type");
for(QStringList::ConstIterator it = types.begin(); it != types.end(); ++it)
type += mAddressTypeMap[(*it).lower()];
bool available = false;
KABC::Address::List addressList = addr.addresses();
KABC::Address::List::Iterator it;
for(it = addressList.begin(); it != addressList.end(); ++it)
{
if((*it).type() == type)
{
(*it).setLabel((*lineIt).value().asString());
addr.insertAddress(*it);
available = true;
break;
}
}
if(!available)
{ // a standalone LABEL tag
KABC::Address address(type);
address.setLabel((*lineIt).value().asString());
addr.insertAddress(address);
}
}
// LOGO
else if(identifier == "logo")
addr.setLogo(parsePicture(*lineIt));
// MAILER
else if(identifier == "mailer")
addr.setMailer((*lineIt).value().asString());
// N
else if(identifier == "n")
{
const QStringList nameParts = splitString(semicolonSep, (*lineIt).value().asString());
if(nameParts.count() > 0)
addr.setFamilyName(nameParts[0]);
if(nameParts.count() > 1)
addr.setGivenName(nameParts[1]);
if(nameParts.count() > 2)
addr.setAdditionalName(nameParts[2]);
if(nameParts.count() > 3)
addr.setPrefix(nameParts[3]);
if(nameParts.count() > 4)
addr.setSuffix(nameParts[4]);
}
// NAME
else if(identifier == "name")
addr.setName((*lineIt).value().asString());
// NICKNAME
else if(identifier == "nickname")
addr.setNickName((*lineIt).value().asString());
// NOTE
else if(identifier == "note")
addr.setNote((*lineIt).value().asString());
// ORGANIZATION
else if(identifier == "org")
{
const QStringList orgParts = splitString(semicolonSep, (*lineIt).value().asString());
if(orgParts.count() > 0)
addr.setOrganization(orgParts[0]);
if(orgParts.count() > 1)
addr.setDepartment(orgParts[1]);
}
// PHOTO
else if(identifier == "photo")
addr.setPhoto(parsePicture(*lineIt));
// PROID
else if(identifier == "prodid")
addr.setProductId((*lineIt).value().asString());
// REV
else if(identifier == "rev")
addr.setRevision(parseDateTime((*lineIt).value().asString()));
// ROLE
else if(identifier == "role")
addr.setRole((*lineIt).value().asString());
// SORT-STRING
else if(identifier == "sort-string")
addr.setSortString((*lineIt).value().asString());
// SOUND
else if(identifier == "sound")
addr.setSound(parseSound(*lineIt));
// TEL
else if(identifier == "tel")
{
PhoneNumber phone;
phone.setNumber((*lineIt).value().asString());
int type = 0;
const QStringList types = (*lineIt).parameters("type");
for(QStringList::ConstIterator it = types.begin(); it != types.end(); ++it)
type += mPhoneTypeMap[(*it).upper()];
phone.setType(type);
addr.insertPhoneNumber(phone);
}
// TITLE
else if(identifier == "title")
addr.setTitle((*lineIt).value().asString());
// TZ
else if(identifier == "tz")
{
TimeZone tz;
const QString date = (*lineIt).value().asString();
int hours = date.mid(1, 2).toInt();
int minutes = date.mid(4, 2).toInt();
int offset = (hours * 60) + minutes;
offset = offset * (date[0] == '+' ? 1 : -1);
tz.setOffset(offset);
addr.setTimeZone(tz);
}
// UID
else if(identifier == "uid")
addr.setUid((*lineIt).value().asString());
// URL
else if(identifier == "url")
addr.setUrl(KURL((*lineIt).value().asString()));
// X-
else if(identifier.startsWith("x-"))
{
const QString key = (*lineIt).identifier().mid(2);
int dash = key.find("-");
addr.insertCustom(key.left(dash), key.mid(dash + 1), (*lineIt).value().asString());
}
}
}
addrList.append(addr);
}
return addrList;
}
CPhone::TNumberKind CPhone::parseAndFormatForResolver(const wxString& val,
wxString& nationalNr,
wxString& e164Nr)
{
initClass();
TNumberKind rc = INVALID;
nationalNr = val;
e164Nr = val;
if (isInternalNumber(val)) {
return INTERNAL;
}
PhoneNumber phoneNr;
std::string strCC = m_Prefs->getPrefs().getCC();
PhoneNumberUtil::ErrorType err = m_PhoneUtil->ParseAndKeepRawInput(
val.ToUTF8().data(), strCC, &phoneNr);
if (err != PhoneNumberUtil::NO_PARSING_ERROR)
return INVALID;
if (phoneNr.has_country_code() &&
(phoneNr.country_code_source() != PhoneNumber_CountryCodeSource_FROM_DEFAULT_COUNTRY))
{
if (phoneNr.country_code() != m_PhoneUtil->GetCountryCodeForRegion(strCC)) {
// Phone Number has an IDD other than current country, so format for international dialing
std::string number;
m_PhoneUtil->FormatInOriginalFormat(phoneNr, strCC, &number);
nationalNr = wxString::FromUTF8(number.c_str());
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::E164, &number);
e164Nr = wxString::FromUTF8(number.c_str());
return INTERNATIONAL;
}
// Phone Number has own IDD, so format national for resolver
std::string number;
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::NATIONAL, &number);
nationalNr = wxString::FromUTF8(number.c_str());
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::E164, &number);
e164Nr = wxString::FromUTF8(number.c_str());
return NATIONAL_RESOLVABLE;
}
// Seems to be a national number
std::string number;
wxString strNDD = m_mapNdd[strCC];
if (strNDD.empty()) {
std::string number;
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::NATIONAL, &number);
nationalNr = wxString::FromUTF8(number.c_str());
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::E164, &number);
e164Nr = wxString::FromUTF8(number.c_str());
return NATIONAL_RESOLVABLE;
}
if (val.StartsWith(strNDD)) { // probably with area code
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::NATIONAL, &number);
nationalNr = wxString::FromUTF8(number.c_str());
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::E164, &number);
e164Nr = wxString::FromUTF8(number.c_str());
return NATIONAL_RESOLVABLE;
}
// probably local number without area code, so return a formatted
// number with added area code if one is set in the preferences
std::string strAC = m_Prefs->getPrefs().getAC();
bool bAddAC = m_Prefs->getPrefs().addACIfShortLen();
int nLocalMaxLen = m_Prefs->getPrefs().getLocalNrMaxLen();
if (bAddAC && !strAC.empty() && (val.Length() < nLocalMaxLen))
{
std::string nsn;
m_PhoneUtil->GetNationalSignificantNumber(phoneNr, &nsn);
number = strAC; number += nsn;
err = m_PhoneUtil->Parse(number, strCC, &phoneNr);
if (err == PhoneNumberUtil::NO_PARSING_ERROR) {
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::NATIONAL, &number);
nationalNr = wxString::FromUTF8(number.c_str());
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::E164, &number);
e164Nr = wxString::FromUTF8(number.c_str());
return NATIONAL_RESOLVABLE;
}
}
m_PhoneUtil->Format(phoneNr, PhoneNumberUtil::E164, &number);
e164Nr = wxString::FromUTF8(number.c_str());
return NATIONAL;
}
