components/autofill/content/browser/wallet/wallet_address.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "components/autofill/content/browser/wallet/wallet_address.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/string_split.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "base/values.h"
  12 #include "components/autofill/core/browser/autofill_country.h"
  13 #include "components/autofill/core/browser/autofill_profile.h"
  14 #include "components/autofill/core/browser/autofill_type.h"
  15 #include "components/autofill/core/browser/phone_number.h"
  16 #include "components/autofill/core/browser/state_names.h"
  17
  18 namespace autofill {
  19 namespace wallet {
  20
  21 // Server specified type for address with complete details.
  22 const char kFullAddress[] = "FULL";
  23
  24 namespace {
  25
  26 Address* CreateAddressInternal(const base::DictionaryValue& dictionary,
  27                                const std::string& object_id) {
  28   std::string country_name_code;
  29   if (!dictionary.GetString("postal_address.country_name_code",
  30                             &country_name_code)) {
  31     DLOG(ERROR) << "Response from Google Wallet missing country name";
  32     return NULL;
  33   }
  34
  35   base::string16 recipient_name;
  36   if (!dictionary.GetString("postal_address.recipient_name",
  37                             &recipient_name)) {
  38     DLOG(ERROR) << "Response from Google Wallet missing recipient name";
  39     return NULL;
  40   }
  41
  42   base::string16 postal_code_number;
  43   if (!dictionary.GetString("postal_address.postal_code_number",
  44                             &postal_code_number)) {
  45     DLOG(ERROR) << "Response from Google Wallet missing postal code number";
  46     return NULL;
  47   }
  48   // TODO(estade): what about postal_code_number_extension?
  49
  50   base::string16 sorting_code;
  51   if (!dictionary.GetString("postal_address.sorting_code",
  52                             &sorting_code)) {
  53     DVLOG(1) << "Response from Google Wallet missing sorting code";
  54   }
  55
  56   base::string16 phone_number;
  57   if (!dictionary.GetString("phone_number", &phone_number))
  58     DVLOG(1) << "Response from Google Wallet missing phone number";
  59
  60   std::vector<base::string16> street_address;
  61   const base::ListValue* address_line_list;
  62   if (dictionary.GetList("postal_address.address_line", &address_line_list)) {
  63     for (size_t i = 0; i < address_line_list->GetSize(); ++i) {
  64       base::string16 line;
  65       address_line_list->GetString(i, &line);
  66       street_address.push_back(line);
  67     }
  68   } else {
  69     DVLOG(1) << "Response from Google Wallet missing address lines";
  70   }
  71
  72   base::string16 locality_name;
  73   if (!dictionary.GetString("postal_address.locality_name",
  74                             &locality_name)) {
  75     DVLOG(1) << "Response from Google Wallet missing locality name";
  76   }
  77
  78   base::string16 dependent_locality_name;
  79   if (!dictionary.GetString("postal_address.dependent_locality_name",
  80                             &dependent_locality_name)) {
  81     DVLOG(1) << "Response from Google Wallet missing dependent locality name";
  82   }
  83
  84   base::string16 administrative_area_name;
  85   if (!dictionary.GetString("postal_address.administrative_area_name",
  86                             &administrative_area_name)) {
  87     DVLOG(1) << "Response from Google Wallet missing administrative area name";
  88   }
  89
  90   std::string language_code;
  91   if (!dictionary.GetString("postal_address.language_code",
  92                             &language_code)) {
  93     DVLOG(1) << "Response from Google Wallet missing language code";
  94   }
  95
  96   Address* address = new Address(country_name_code,
  97                                  recipient_name,
  98                                  street_address,
  99                                  locality_name,
 100                                  dependent_locality_name,
 101                                  administrative_area_name,
 102                                  postal_code_number,
 103                                  sorting_code,
 104                                  phone_number,
 105                                  object_id,
 106                                  language_code);
 107
 108   bool is_minimal_address = false;
 109   if (dictionary.GetBoolean("is_minimal_address", &is_minimal_address))
 110     address->set_is_complete_address(!is_minimal_address);
 111   else
 112     DVLOG(1) << "Response from Google Wallet missing is_minimal_address bit";
 113
 114   return address;
 115 }
 116
 117 }  // namespace
 118
 119 Address::Address() {}
 120
 121 Address::Address(const AutofillProfile& profile)
 122     : country_name_code_(
 123           base::UTF16ToASCII(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))),
 124       recipient_name_(profile.GetRawInfo(NAME_FULL)),
 125       locality_name_(profile.GetRawInfo(ADDRESS_HOME_CITY)),
 126       dependent_locality_name_(
 127           profile.GetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY)),
 128       administrative_area_name_(profile.GetRawInfo(ADDRESS_HOME_STATE)),
 129       postal_code_number_(profile.GetRawInfo(ADDRESS_HOME_ZIP)),
 130       sorting_code_(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE)),
 131       phone_number_(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)),
 132       is_complete_address_(true),
 133       language_code_(profile.language_code()) {
 134   base::SplitString(
 135       profile.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS), '\n', &street_address_);
 136
 137   if (!country_name_code_.empty())
 138     phone_object_ = i18n::PhoneObject(phone_number_, country_name_code_);
 139 }
 140
 141 Address::Address(const std::string& country_name_code,
 142                  const base::string16& recipient_name,
 143                  const std::vector<base::string16>& street_address,
 144                  const base::string16& locality_name,
 145                  const base::string16& dependent_locality_name,
 146                  const base::string16& administrative_area_name,
 147                  const base::string16& postal_code_number,
 148                  const base::string16& sorting_code,
 149                  const base::string16& phone_number,
 150                  const std::string& object_id,
 151                  const std::string& language_code)
 152     : country_name_code_(country_name_code),
 153       recipient_name_(recipient_name),
 154       street_address_(street_address),
 155       locality_name_(locality_name),
 156       dependent_locality_name_(dependent_locality_name),
 157       administrative_area_name_(administrative_area_name),
 158       postal_code_number_(postal_code_number),
 159       sorting_code_(sorting_code),
 160       phone_number_(phone_number),
 161       phone_object_(phone_number, country_name_code),
 162       object_id_(object_id),
 163       is_complete_address_(true),
 164       language_code_(language_code) {}
 165
 166 Address::~Address() {}
 167
 168 // static
 169 scoped_ptr<Address> Address::CreateAddressWithID(
 170     const base::DictionaryValue& dictionary) {
 171   std::string object_id;
 172   if (!dictionary.GetString("id", &object_id)) {
 173     DLOG(ERROR) << "Response from Google Wallet missing object id";
 174     return scoped_ptr<Address>();
 175   }
 176   return scoped_ptr<Address>(CreateAddressInternal(dictionary, object_id));
 177 }
 178
 179 // static
 180 scoped_ptr<Address> Address::CreateAddress(
 181     const base::DictionaryValue& dictionary) {
 182   std::string object_id;
 183   dictionary.GetString("id", &object_id);
 184   return scoped_ptr<Address>(CreateAddressInternal(dictionary, object_id));
 185 }
 186
 187 // static
 188 scoped_ptr<Address> Address::CreateDisplayAddress(
 189     const base::DictionaryValue& dictionary) {
 190   std::string country_code;
 191   if (!dictionary.GetString("country_code", &country_code)) {
 192     DLOG(ERROR) << "Reponse from Google Wallet missing country code";
 193     return scoped_ptr<Address>();
 194   }
 195
 196   base::string16 name;
 197   if (!dictionary.GetString("name", &name)) {
 198     DLOG(ERROR) << "Reponse from Google Wallet missing name";
 199     return scoped_ptr<Address>();
 200   }
 201
 202   base::string16 postal_code;
 203   if (!dictionary.GetString("postal_code", &postal_code)) {
 204     DLOG(ERROR) << "Reponse from Google Wallet missing postal code";
 205     return scoped_ptr<Address>();
 206   }
 207
 208   base::string16 sorting_code;
 209   if (!dictionary.GetString("sorting_code", &sorting_code)) {
 210     DVLOG(1) << "Reponse from Google Wallet missing sorting code";
 211   }
 212
 213   std::vector<base::string16> street_address;
 214   base::string16 address1;
 215   if (dictionary.GetString("address1", &address1))
 216     street_address.push_back(address1);
 217   else
 218     DVLOG(1) << "Reponse from Google Wallet missing address1";
 219
 220   base::string16 address2;
 221   if (dictionary.GetString("address2", &address2) && !address2.empty()) {
 222     street_address.resize(2);
 223     street_address[1] = address2;
 224   } else {
 225     DVLOG(1) << "Reponse from Google Wallet missing or empty address2";
 226   }
 227
 228   base::string16 city;
 229   if (!dictionary.GetString("city", &city))
 230     DVLOG(1) << "Reponse from Google Wallet missing city";
 231
 232   base::string16 dependent_locality_name;
 233   if (!dictionary.GetString("dependent_locality_name",
 234                             &dependent_locality_name)) {
 235     DVLOG(1) << "Reponse from Google Wallet missing district";
 236   }
 237
 238   base::string16 state;
 239   if (!dictionary.GetString("state", &state))
 240     DVLOG(1) << "Reponse from Google Wallet missing state";
 241
 242   base::string16 phone_number;
 243   if (!dictionary.GetString("phone_number", &phone_number))
 244     DVLOG(1) << "Reponse from Google Wallet missing phone number";
 245
 246   std::string address_state;
 247   if (!dictionary.GetString("type", &address_state))
 248     DVLOG(1) << "Response from Google Wallet missing type/state of address";
 249
 250   std::string language_code;
 251   if (!dictionary.GetString("language_code", &language_code))
 252     DVLOG(1) << "Response from Google Wallet missing language code";
 253
 254   scoped_ptr<Address> address(
 255       new Address(country_code,
 256                   name,
 257                   street_address,
 258                   city,
 259                   dependent_locality_name,
 260                   state,
 261                   postal_code,
 262                   sorting_code,
 263                   phone_number,
 264                   std::string(),
 265                   language_code));
 266   address->set_is_complete_address(address_state == kFullAddress);
 267
 268   return address.Pass();
 269 }
 270
 271 scoped_ptr<base::DictionaryValue> Address::ToDictionaryWithID() const {
 272   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 273
 274   if (!object_id_.empty())
 275     dict->SetString("id", object_id_);
 276   dict->SetString("phone_number", phone_number_);
 277   dict->Set("postal_address", ToDictionaryWithoutID().release());
 278
 279   return dict.Pass();
 280 }
 281
 282 scoped_ptr<base::DictionaryValue> Address::ToDictionaryWithoutID() const {
 283   scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
 284
 285   scoped_ptr<base::ListValue> address_lines(new base::ListValue());
 286   address_lines->AppendStrings(street_address_);
 287   dict->Set("address_line", address_lines.release());
 288
 289   dict->SetString("country_name_code", country_name_code_);
 290   dict->SetString("recipient_name", recipient_name_);
 291   dict->SetString("locality_name", locality_name_);
 292   dict->SetString("dependent_locality_name", dependent_locality_name_);
 293   dict->SetString("administrative_area_name",
 294                   administrative_area_name_);
 295   dict->SetString("postal_code_number", postal_code_number_);
 296   dict->SetString("sorting_code", sorting_code_);
 297   dict->SetString("language_code", language_code_);
 298
 299   return dict.Pass();
 300 }
 301
 302 base::string16 Address::DisplayName() const {
 303 #if defined(OS_ANDROID)
 304   // TODO(aruslan): improve this stub implementation.
 305   return recipient_name();
 306 #else
 307   // TODO(estade): improve this stub implementation + l10n.
 308   return recipient_name() + base::ASCIIToUTF16(", ") + GetStreetAddressLine(0);
 309 #endif
 310 }
 311
 312 base::string16 Address::DisplayNameDetail() const {
 313 #if defined(OS_ANDROID)
 314   // TODO(aruslan): improve this stub implementation.
 315   return GetStreetAddressLine(0);
 316 #else
 317   return base::string16();
 318 #endif
 319 }
 320
 321 base::string16 Address::DisplayPhoneNumber() const {
 322   // Return a formatted phone number. Wallet doesn't store user formatting, so
 323   // impose our own. phone_number() always includes a country code, so using
 324   // PhoneObject to format it would result in an internationalized format. Since
 325   // Wallet only supports the US right now, stick to national formatting.
 326   return i18n::PhoneObject(phone_number(), country_name_code()).
 327       GetNationallyFormattedNumber();
 328 }
 329
 330 base::string16 Address::GetInfo(const AutofillType& type,
 331                                 const std::string& app_locale) const {
 332   if (type.html_type() == HTML_TYPE_COUNTRY_CODE) {
 333     DCHECK(base::IsStringASCII(country_name_code()));
 334     return base::ASCIIToUTF16(country_name_code());
 335   }
 336
 337   switch (type.GetStorableType()) {
 338     case NAME_FULL:
 339       return recipient_name();
 340
 341     case ADDRESS_HOME_STREET_ADDRESS:
 342       return JoinString(street_address_, base::ASCIIToUTF16("\n"));
 343
 344     case ADDRESS_HOME_LINE1:
 345       return GetStreetAddressLine(0);
 346
 347     case ADDRESS_HOME_LINE2:
 348       return GetStreetAddressLine(1);
 349
 350     case ADDRESS_HOME_CITY:
 351       return locality_name();
 352
 353     case ADDRESS_HOME_STATE:
 354       return administrative_area_name();
 355
 356     case ADDRESS_HOME_ZIP:
 357       return postal_code_number();
 358
 359     case ADDRESS_HOME_COUNTRY: {
 360       AutofillCountry country(country_name_code(), app_locale);
 361       return country.name();
 362     }
 363
 364     case PHONE_HOME_WHOLE_NUMBER:
 365       // Wallet doesn't store user phone number formatting, so just strip all
 366       // formatting.
 367       return phone_object_.GetWholeNumber();
 368
 369     case ADDRESS_HOME_DEPENDENT_LOCALITY:
 370       return dependent_locality_name_;
 371
 372     case ADDRESS_HOME_SORTING_CODE:
 373       return sorting_code_;
 374
 375     case COMPANY_NAME:
 376       // A field that Wallet doesn't support. TODO(dbeam): can it be supported?
 377       return base::string16();
 378
 379     default:
 380       NOTREACHED();
 381       return base::string16();
 382   }
 383 }
 384
 385 void Address::SetPhoneNumber(const base::string16& phone_number) {
 386   phone_number_ = phone_number;
 387   phone_object_ = i18n::PhoneObject(phone_number_, country_name_code_);
 388 }
 389
 390 bool Address::EqualsIgnoreID(const Address& other) const {
 391   return country_name_code_ == other.country_name_code_ &&
 392          recipient_name_ == other.recipient_name_ &&
 393          street_address_ == other.street_address_ &&
 394          locality_name_ == other.locality_name_ &&
 395          dependent_locality_name_ == other.dependent_locality_name_ &&
 396          administrative_area_name_ == other.administrative_area_name_ &&
 397          postal_code_number_ == other.postal_code_number_ &&
 398          sorting_code_ == other.sorting_code_ &&
 399          phone_number_ == other.phone_number_ &&
 400          is_complete_address_ == other.is_complete_address_;
 401 }
 402
 403 base::string16 Address::GetStreetAddressLine(size_t line) const {
 404   return street_address_.size() > line ? street_address_[line] :
 405                                          base::string16();
 406 }
 407
 408 bool Address::operator==(const Address& other) const {
 409   return object_id_ == other.object_id_ &&
 410          language_code_ == other.language_code_ &&
 411          EqualsIgnoreID(other);
 412 }
 413
 414 bool Address::operator!=(const Address& other) const {
 415   return !(*this == other);
 416 }
 417
 418 }  // namespace wallet
 419 }  // namespace autofill