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

// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/autofill/content/browser/wallet/wallet_address.h"

#include "base/logging.h"
#include "base/strings/string_split.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "components/autofill/core/browser/autofill_country.h"
#include "components/autofill/core/browser/autofill_profile.h"
#include "components/autofill/core/browser/autofill_type.h"
#include "components/autofill/core/browser/phone_number.h"
#include "components/autofill/core/browser/state_names.h"

namespace autofill {
namespace wallet {

// Server specified type for address with complete details.
const char kFullAddress[] = "FULL";

namespace {

Address* CreateAddressInternal(const base::DictionaryValue& dictionary,
                               const std::string& object_id) {
  std::string country_name_code;
  if (!dictionary.GetString("postal_address.country_name_code",
                            &country_name_code)) {
    DLOG(ERROR) << "Response from Google Wallet missing country name";
    return NULL;
  }

  base::string16 recipient_name;
  if (!dictionary.GetString("postal_address.recipient_name",
                            &recipient_name)) {
    DLOG(ERROR) << "Response from Google Wallet missing recipient name";
    return NULL;
  }

  base::string16 postal_code_number;
  if (!dictionary.GetString("postal_address.postal_code_number",
                            &postal_code_number)) {
    DLOG(ERROR) << "Response from Google Wallet missing postal code number";
    return NULL;
  }
  // TODO(estade): what about postal_code_number_extension?

  base::string16 sorting_code;
  if (!dictionary.GetString("postal_address.sorting_code",
                            &sorting_code)) {
    DVLOG(1) << "Response from Google Wallet missing sorting code";
  }

  base::string16 phone_number;
  if (!dictionary.GetString("phone_number", &phone_number))
    DVLOG(1) << "Response from Google Wallet missing phone number";

  std::vector<base::string16> street_address;
  const base::ListValue* address_line_list;
  if (dictionary.GetList("postal_address.address_line", &address_line_list)) {
    for (size_t i = 0; i < address_line_list->GetSize(); ++i) {
      base::string16 line;
      address_line_list->GetString(i, &line);
      street_address.push_back(line);
    }
  } else {
    DVLOG(1) << "Response from Google Wallet missing address lines";
  }

  base::string16 locality_name;
  if (!dictionary.GetString("postal_address.locality_name",
                            &locality_name)) {
    DVLOG(1) << "Response from Google Wallet missing locality name";
  }

  base::string16 dependent_locality_name;
  if (!dictionary.GetString("postal_address.dependent_locality_name",
                            &dependent_locality_name)) {
    DVLOG(1) << "Response from Google Wallet missing dependent locality name";
  }

  base::string16 administrative_area_name;
  if (!dictionary.GetString("postal_address.administrative_area_name",
                            &administrative_area_name)) {
    DVLOG(1) << "Response from Google Wallet missing administrative area name";
  }

  std::string language_code;
  if (!dictionary.GetString("postal_address.language_code",
                            &language_code)) {
    DVLOG(1) << "Response from Google Wallet missing language code";
  }

  Address* address = new Address(country_name_code,
                                 recipient_name,
                                 street_address,
                                 locality_name,
                                 dependent_locality_name,
                                 administrative_area_name,
                                 postal_code_number,
                                 sorting_code,
                                 phone_number,
                                 object_id,
                                 language_code);

  bool is_minimal_address = false;
  if (dictionary.GetBoolean("is_minimal_address", &is_minimal_address))
    address->set_is_complete_address(!is_minimal_address);
  else
    DVLOG(1) << "Response from Google Wallet missing is_minimal_address bit";

  return address;
}

}  // namespace

Address::Address() {}

Address::Address(const AutofillProfile& profile)
    : country_name_code_(
          base::UTF16ToASCII(profile.GetRawInfo(ADDRESS_HOME_COUNTRY))),
      recipient_name_(profile.GetRawInfo(NAME_FULL)),
      locality_name_(profile.GetRawInfo(ADDRESS_HOME_CITY)),
      dependent_locality_name_(
          profile.GetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY)),
      administrative_area_name_(profile.GetRawInfo(ADDRESS_HOME_STATE)),
      postal_code_number_(profile.GetRawInfo(ADDRESS_HOME_ZIP)),
      sorting_code_(profile.GetRawInfo(ADDRESS_HOME_SORTING_CODE)),
      phone_number_(profile.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)),
      is_complete_address_(true),
      language_code_(profile.language_code()) {
  base::SplitString(
      profile.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS), '\n', &street_address_);

  if (!country_name_code_.empty())
    phone_object_ = i18n::PhoneObject(phone_number_, country_name_code_);
}

Address::Address(const std::string& country_name_code,
                 const base::string16& recipient_name,
                 const std::vector<base::string16>& street_address,
                 const base::string16& locality_name,
                 const base::string16& dependent_locality_name,
                 const base::string16& administrative_area_name,
                 const base::string16& postal_code_number,
                 const base::string16& sorting_code,
                 const base::string16& phone_number,
                 const std::string& object_id,
                 const std::string& language_code)
    : country_name_code_(country_name_code),
      recipient_name_(recipient_name),
      street_address_(street_address),
      locality_name_(locality_name),
      dependent_locality_name_(dependent_locality_name),
      administrative_area_name_(administrative_area_name),
      postal_code_number_(postal_code_number),
      sorting_code_(sorting_code),
      phone_number_(phone_number),
      phone_object_(phone_number, country_name_code),
      object_id_(object_id),
      is_complete_address_(true),
      language_code_(language_code) {}

Address::~Address() {}

// static
scoped_ptr<Address> Address::CreateAddressWithID(
    const base::DictionaryValue& dictionary) {
  std::string object_id;
  if (!dictionary.GetString("id", &object_id)) {
    DLOG(ERROR) << "Response from Google Wallet missing object id";
    return scoped_ptr<Address>();
  }
  return scoped_ptr<Address>(CreateAddressInternal(dictionary, object_id));
}

// static
scoped_ptr<Address> Address::CreateAddress(
    const base::DictionaryValue& dictionary) {
  std::string object_id;
  dictionary.GetString("id", &object_id);
  return scoped_ptr<Address>(CreateAddressInternal(dictionary, object_id));
}

// static
scoped_ptr<Address> Address::CreateDisplayAddress(
    const base::DictionaryValue& dictionary) {
  std::string country_code;
  if (!dictionary.GetString("country_code", &country_code)) {
    DLOG(ERROR) << "Reponse from Google Wallet missing country code";
    return scoped_ptr<Address>();
  }

  base::string16 name;
  if (!dictionary.GetString("name", &name)) {
    DLOG(ERROR) << "Reponse from Google Wallet missing name";
    return scoped_ptr<Address>();
  }

  base::string16 postal_code;
  if (!dictionary.GetString("postal_code", &postal_code)) {
    DLOG(ERROR) << "Reponse from Google Wallet missing postal code";
    return scoped_ptr<Address>();
  }

  base::string16 sorting_code;
  if (!dictionary.GetString("sorting_code", &sorting_code)) {
    DVLOG(1) << "Reponse from Google Wallet missing sorting code";
  }

  std::vector<base::string16> street_address;
  base::string16 address1;
  if (dictionary.GetString("address1", &address1))
    street_address.push_back(address1);
  else
    DVLOG(1) << "Reponse from Google Wallet missing address1";

  base::string16 address2;
  if (dictionary.GetString("address2", &address2) && !address2.empty()) {
    street_address.resize(2);
    street_address[1] = address2;
  } else {
    DVLOG(1) << "Reponse from Google Wallet missing or empty address2";
  }

  base::string16 city;
  if (!dictionary.GetString("city", &city))
    DVLOG(1) << "Reponse from Google Wallet missing city";

  base::string16 dependent_locality_name;
  if (!dictionary.GetString("dependent_locality_name",
                            &dependent_locality_name)) {
    DVLOG(1) << "Reponse from Google Wallet missing district";
  }

  base::string16 state;
  if (!dictionary.GetString("state", &state))
    DVLOG(1) << "Reponse from Google Wallet missing state";

  base::string16 phone_number;
  if (!dictionary.GetString("phone_number", &phone_number))
    DVLOG(1) << "Reponse from Google Wallet missing phone number";

  std::string address_state;
  if (!dictionary.GetString("type", &address_state))
    DVLOG(1) << "Response from Google Wallet missing type/state of address";

  std::string language_code;
  if (!dictionary.GetString("language_code", &language_code))
    DVLOG(1) << "Response from Google Wallet missing language code";

  scoped_ptr<Address> address(
      new Address(country_code,
                  name,
                  street_address,
                  city,
                  dependent_locality_name,
                  state,
                  postal_code,
                  sorting_code,
                  phone_number,
                  std::string(),
                  language_code));
  address->set_is_complete_address(address_state == kFullAddress);

  return address.Pass();
}

scoped_ptr<base::DictionaryValue> Address::ToDictionaryWithID() const {
  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

  if (!object_id_.empty())
    dict->SetString("id", object_id_);
  dict->SetString("phone_number", phone_number_);
  dict->Set("postal_address", ToDictionaryWithoutID().release());

  return dict.Pass();
}

scoped_ptr<base::DictionaryValue> Address::ToDictionaryWithoutID() const {
  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

  scoped_ptr<base::ListValue> address_lines(new base::ListValue());
  address_lines->AppendStrings(street_address_);
  dict->Set("address_line", address_lines.release());

  dict->SetString("country_name_code", country_name_code_);
  dict->SetString("recipient_name", recipient_name_);
  dict->SetString("locality_name", locality_name_);
  dict->SetString("dependent_locality_name", dependent_locality_name_);
  dict->SetString("administrative_area_name",
                  administrative_area_name_);
  dict->SetString("postal_code_number", postal_code_number_);
  dict->SetString("sorting_code", sorting_code_);
  dict->SetString("language_code", language_code_);

  return dict.Pass();
}

base::string16 Address::DisplayName() const {
#if defined(OS_ANDROID)
  // TODO(aruslan): improve this stub implementation.
  return recipient_name();
#else
  // TODO(estade): improve this stub implementation + l10n.
  return recipient_name() + base::ASCIIToUTF16(", ") + GetStreetAddressLine(0);
#endif
}

base::string16 Address::DisplayNameDetail() const {
#if defined(OS_ANDROID)
  // TODO(aruslan): improve this stub implementation.
  return GetStreetAddressLine(0);
#else
  return base::string16();
#endif
}

base::string16 Address::DisplayPhoneNumber() const {
  // Return a formatted phone number. Wallet doesn't store user formatting, so
  // impose our own. phone_number() always includes a country code, so using
  // PhoneObject to format it would result in an internationalized format. Since
  // Wallet only supports the US right now, stick to national formatting.
  return i18n::PhoneObject(phone_number(), country_name_code()).
      GetNationallyFormattedNumber();
}

base::string16 Address::GetInfo(const AutofillType& type,
                                const std::string& app_locale) const {
  if (type.html_type() == HTML_TYPE_COUNTRY_CODE) {
    DCHECK(base::IsStringASCII(country_name_code()));
    return base::ASCIIToUTF16(country_name_code());
  }

  switch (type.GetStorableType()) {
    case NAME_FULL:
      return recipient_name();

    case ADDRESS_HOME_STREET_ADDRESS:
      return JoinString(street_address_, base::ASCIIToUTF16("\n"));

    case ADDRESS_HOME_LINE1:
      return GetStreetAddressLine(0);

    case ADDRESS_HOME_LINE2:
      return GetStreetAddressLine(1);

    case ADDRESS_HOME_CITY:
      return locality_name();

    case ADDRESS_HOME_STATE:
      return administrative_area_name();

    case ADDRESS_HOME_ZIP:
      return postal_code_number();

    case ADDRESS_HOME_COUNTRY: {
      AutofillCountry country(country_name_code(), app_locale);
      return country.name();
    }

    case PHONE_HOME_WHOLE_NUMBER:
      // Wallet doesn't store user phone number formatting, so just strip all
      // formatting.
      return phone_object_.GetWholeNumber();

    case ADDRESS_HOME_DEPENDENT_LOCALITY:
      return dependent_locality_name_;

    case ADDRESS_HOME_SORTING_CODE:
      return sorting_code_;

    case COMPANY_NAME:
      // A field that Wallet doesn't support. TODO(dbeam): can it be supported?
      return base::string16();

    default:
      NOTREACHED();
      return base::string16();
  }
}

void Address::SetPhoneNumber(const base::string16& phone_number) {
  phone_number_ = phone_number;
  phone_object_ = i18n::PhoneObject(phone_number_, country_name_code_);
}

bool Address::EqualsIgnoreID(const Address& other) const {
  return country_name_code_ == other.country_name_code_ &&
         recipient_name_ == other.recipient_name_ &&
         street_address_ == other.street_address_ &&
         locality_name_ == other.locality_name_ &&
         dependent_locality_name_ == other.dependent_locality_name_ &&
         administrative_area_name_ == other.administrative_area_name_ &&
         postal_code_number_ == other.postal_code_number_ &&
         sorting_code_ == other.sorting_code_ &&
         phone_number_ == other.phone_number_ &&
         is_complete_address_ == other.is_complete_address_;
}

base::string16 Address::GetStreetAddressLine(size_t line) const {
  return street_address_.size() > line ? street_address_[line] :
                                         base::string16();
}

bool Address::operator==(const Address& other) const {
  return object_id_ == other.object_id_ &&
         language_code_ == other.language_code_ &&
         EqualsIgnoreID(other);
}

bool Address::operator!=(const Address& other) const {
  return !(*this == other);
}

}  // namespace wallet
}  // namespace autofill