Home | History | Annotate | Download | only in wallet 
      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 #ifndef COMPONENTS_AUTOFILL_CONTENT_BROWSER_WALLET_WALLET_ITEMS_H_
      6 #define COMPONENTS_AUTOFILL_CONTENT_BROWSER_WALLET_WALLET_ITEMS_H_
      7 
      8 #include <set>
      9 #include <string>
     10 #include <vector>
     11 
     12 #include "base/basictypes.h"
     13 #include "base/gtest_prod_util.h"
     14 #include "base/logging.h"
     15 #include "base/memory/scoped_ptr.h"
     16 #include "base/memory/scoped_vector.h"
     17 #include "base/strings/string16.h"
     18 #include "components/autofill/content/browser/wallet/required_action.h"
     19 #include "components/autofill/content/browser/wallet/wallet_address.h"
     20 #include "url/gurl.h"
     21 
     22 namespace base {
     23 class DictionaryValue;
     24 }
     25 
     26 namespace gfx {
     27 class Image;
     28 }
     29 
     30 namespace autofill {
     31 
     32 class AutofillType;
     33 
     34 FORWARD_DECLARE_TEST(WalletInstrumentWrapperTest, GetInfoCreditCardExpMonth);
     35 FORWARD_DECLARE_TEST(WalletInstrumentWrapperTest,
     36                      GetDisplayTextEmptyWhenExpired);
     37 
     38 namespace wallet {
     39 
     40 class GaiaAccount;
     41 class WalletItemsTest;
     42 
     43 enum AmexPermission {
     44   AMEX_ALLOWED,
     45   AMEX_DISALLOWED,
     46 };
     47 
     48 // WalletItems is a collection of cards and addresses that a user picks from to
     49 // construct a full wallet. However, it also provides a transaction ID which
     50 // must be used throughout all API calls being made using this data.
     51 // Additionally, user actions may be required before a purchase can be completed
     52 // using Online Wallet and those actions are present in the object as well.
     53 class WalletItems {
     54  public:
     55   // Container for all information about a credit card except for it's card
     56   // verfication number (CVN) and it's complete primary account number (PAN).
     57   class MaskedInstrument {
     58    public:
     59     enum Type {
     60       AMEX,
     61       DISCOVER,
     62       MAESTRO,
     63       MASTER_CARD,
     64       SOLO,
     65       SWITCH,
     66       UNKNOWN,  // Catch all type.
     67       VISA,
     68     };
     69     enum Status {
     70       AMEX_NOT_SUPPORTED,
     71       BILLING_INCOMPLETE,
     72       DECLINED,
     73       DISABLED_FOR_THIS_MERCHANT,  // Deprecated.
     74       EXPIRED,
     75       INAPPLICABLE,  // Catch all status.
     76       PENDING,
     77       UNSUPPORTED_COUNTRY,
     78       VALID,
     79     };
     80 
     81     ~MaskedInstrument();
     82 
     83     // Returns an empty scoped_ptr if input is invalid or a valid masked
     84     // instrument.
     85     static scoped_ptr<MaskedInstrument>
     86         CreateMaskedInstrument(const base::DictionaryValue& dictionary);
     87 
     88     bool operator==(const MaskedInstrument& other) const;
     89     bool operator!=(const MaskedInstrument& other) const;
     90 
     91     // Gets an image to display for this instrument.
     92     const gfx::Image& CardIcon() const;
     93 
     94     // Returns a pair of strings that summarizes this CC,
     95     // suitable for display to the user.
     96     base::string16 DisplayName() const;
     97     base::string16 DisplayNameDetail() const;
     98 
     99     // Gets info that corresponds with |type|.
    100     base::string16 GetInfo(const AutofillType& type,
    101                            const std::string& app_locale) const;
    102 
    103     // Returns the display type of the and last four digits (e.g. Visa - 4444).
    104     base::string16 TypeAndLastFourDigits() const;
    105 
    106     const base::string16& descriptive_name() const { return descriptive_name_; }
    107     const Type& type() const { return type_; }
    108     const base::string16& last_four_digits() const { return last_four_digits_; }
    109     int expiration_month() const { return expiration_month_; }
    110     int expiration_year() const { return expiration_year_; }
    111     const Address& address() const { return *address_; }
    112     const Status& status() const { return status_; }
    113     const std::string& object_id() const { return object_id_; }
    114 
    115    private:
    116     friend class WalletItemsTest;
    117     friend scoped_ptr<MaskedInstrument> GetTestMaskedInstrumentWithDetails(
    118         const std::string& id,
    119         scoped_ptr<Address> address,
    120         Type type,
    121         Status status);
    122     FRIEND_TEST_ALL_PREFIXES(::autofill::WalletInstrumentWrapperTest,
    123                              GetInfoCreditCardExpMonth);
    124     FRIEND_TEST_ALL_PREFIXES(::autofill::WalletInstrumentWrapperTest,
    125                              GetDisplayTextEmptyWhenExpired);
    126     FRIEND_TEST_ALL_PREFIXES(WalletItemsTest, CreateMaskedInstrument);
    127     FRIEND_TEST_ALL_PREFIXES(WalletItemsTest, CreateWalletItems);
    128 
    129     MaskedInstrument(const base::string16& descriptive_name,
    130                      const Type& type,
    131                      const base::string16& last_four_digits,
    132                      int expiration_month,
    133                      int expiration_year,
    134                      scoped_ptr<Address> address,
    135                      const Status& status,
    136                      const std::string& object_id);
    137 
    138     // A user-provided description of the instrument. For example, "Google Visa
    139     // Card".
    140     base::string16 descriptive_name_;
    141 
    142     // The payment network of the instrument. For example, Visa.
    143     Type type_;
    144 
    145     // The last four digits of the primary account number of the instrument.
    146     base::string16 last_four_digits_;
    147 
    148     // |expiration month_| should be 1-12.
    149     int expiration_month_;
    150 
    151     // |expiration_year_| should be a 4-digit year.
    152     int expiration_year_;
    153 
    154     // The billing address for the instrument.
    155     scoped_ptr<Address> address_;
    156 
    157     // The current status of the instrument. For example, expired or declined.
    158     Status status_;
    159 
    160     // Externalized Online Wallet id for this instrument.
    161     std::string object_id_;
    162 
    163     DISALLOW_COPY_AND_ASSIGN(MaskedInstrument);
    164   };
    165 
    166   // Class representing a legal document that the user must accept before they
    167   // can use Online Wallet.
    168   class LegalDocument {
    169    public:
    170     ~LegalDocument();
    171 
    172     // Returns null if input is invalid or a valid legal document.
    173     static scoped_ptr<LegalDocument>
    174         CreateLegalDocument(const base::DictionaryValue& dictionary);
    175 
    176     // Returns a document for the privacy policy (acceptance of which is not
    177     // tracked by the server).
    178     static scoped_ptr<LegalDocument> CreatePrivacyPolicyDocument();
    179 
    180     bool operator==(const LegalDocument& other) const;
    181     bool operator!=(const LegalDocument& other) const;
    182 
    183     const std::string& id() { return id_; }
    184     const GURL& url() const { return url_; }
    185     const base::string16& display_name() const { return display_name_; }
    186 
    187    private:
    188     friend class WalletItemsTest;
    189     FRIEND_TEST_ALL_PREFIXES(WalletItemsTest, CreateLegalDocument);
    190     FRIEND_TEST_ALL_PREFIXES(WalletItemsTest, CreateWalletItems);
    191     FRIEND_TEST_ALL_PREFIXES(WalletItemsTest, LegalDocumentUrl);
    192     FRIEND_TEST_ALL_PREFIXES(WalletItemsTest, LegalDocumentEmptyId);
    193     LegalDocument(const std::string& id,
    194                   const base::string16& display_name);
    195     LegalDocument(const GURL& url,
    196                   const base::string16& display_name);
    197 
    198     // Externalized Online Wallet id for the document, or an empty string for
    199     // documents not tracked by the server (such as the privacy policy).
    200     std::string id_;
    201     // The human-visitable URL that displays the document.
    202     GURL url_;
    203     // User displayable name for the document.
    204     base::string16 display_name_;
    205     DISALLOW_COPY_AND_ASSIGN(LegalDocument);
    206   };
    207 
    208   ~WalletItems();
    209 
    210   // Returns null on invalid input, an empty wallet items with required
    211   // actions if any are present, and a populated wallet items otherwise. Caller
    212   // owns returned pointer.
    213   static scoped_ptr<WalletItems>
    214       CreateWalletItems(const base::DictionaryValue& dictionary);
    215 
    216   bool operator==(const WalletItems& other) const;
    217   bool operator!=(const WalletItems& other) const;
    218 
    219   void AddAccount(scoped_ptr<GaiaAccount> account);
    220   void AddInstrument(scoped_ptr<MaskedInstrument> instrument) {
    221     DCHECK(instrument);
    222     instruments_.push_back(instrument.release());
    223   }
    224   void AddAddress(scoped_ptr<Address> address) {
    225     DCHECK(address);
    226     addresses_.push_back(address.release());
    227   }
    228   void AddLegalDocument(scoped_ptr<LegalDocument> legal_document) {
    229     DCHECK(legal_document);
    230     legal_documents_.push_back(legal_document.release());
    231   }
    232   void AddAllowedShippingCountry(const std::string& country_code) {
    233     allowed_shipping_countries_.insert(country_code);
    234   }
    235 
    236   // Return the corresponding instrument for |id| or NULL if it doesn't exist.
    237   const WalletItems::MaskedInstrument* GetInstrumentById(
    238       const std::string& object_id) const;
    239 
    240   // Whether or not |action| is in |required_actions_|.
    241   bool HasRequiredAction(RequiredAction action) const;
    242 
    243   // Checks whether |card_number| is supported by Wallet for this merchant and
    244   // if not, fills in |message| with a user-visible explanation.
    245   bool SupportsCard(const base::string16& card_number,
    246                     base::string16* message) const;
    247 
    248   const std::vector<GaiaAccount*>& gaia_accounts() const {
    249     return gaia_accounts_.get();
    250   }
    251   const std::vector<RequiredAction>& required_actions() const {
    252     return required_actions_;
    253   }
    254   const std::string& google_transaction_id() const {
    255     return google_transaction_id_;
    256   }
    257   const std::vector<MaskedInstrument*>& instruments() const {
    258     return instruments_.get();
    259   }
    260   const std::string& default_instrument_id() const {
    261     return default_instrument_id_;
    262   }
    263   const std::vector<Address*>& addresses() const { return addresses_.get(); }
    264   const std::string& default_address_id() const { return default_address_id_; }
    265   // Returns the GAIA id of the active account, or an empty string if no account
    266   // is active.
    267   std::string ObfuscatedGaiaId() const;
    268   size_t active_account_index() const { return active_account_index_; }
    269   const std::vector<LegalDocument*>& legal_documents() const {
    270     return legal_documents_.get();
    271   }
    272   const std::set<std::string>& allowed_shipping_countries() const {
    273     return allowed_shipping_countries_;
    274   }
    275 
    276  private:
    277   friend class WalletItemsTest;
    278   friend scoped_ptr<WalletItems> GetTestWalletItemsWithDetails(
    279       const std::vector<RequiredAction>& required_actions,
    280       const std::string& default_instrument_id,
    281       const std::string& default_address_id,
    282       AmexPermission amex_permission);
    283   friend scoped_ptr<WalletItems> GetTestWalletItemsWithDefaultIds(
    284       RequiredAction action);
    285   FRIEND_TEST_ALL_PREFIXES(WalletItemsTest, CreateWalletItems);
    286   FRIEND_TEST_ALL_PREFIXES(WalletItemsTest,
    287                            CreateWalletItemsWithRequiredActions);
    288 
    289   WalletItems(const std::vector<RequiredAction>& required_actions,
    290               const std::string& google_transaction_id,
    291               const std::string& default_instrument_id,
    292               const std::string& default_address_id,
    293               AmexPermission amex_permission);
    294 
    295   // Actions that must be completed by the user before a FullWallet can be
    296   // issued to them by the Online Wallet service.
    297   std::vector<RequiredAction> required_actions_;
    298 
    299   // The id for this transaction issued by Google.
    300   std::string google_transaction_id_;
    301 
    302   // The id of the user's default instrument.
    303   std::string default_instrument_id_;
    304 
    305   // The id of the user's default address.
    306   std::string default_address_id_;
    307 
    308   // The index into |gaia_accounts_| of the account for which this object
    309   // holds data.
    310   size_t active_account_index_;
    311 
    312   // The complete set of logged in GAIA accounts.
    313   ScopedVector<GaiaAccount> gaia_accounts_;
    314 
    315   // The user's backing instruments.
    316   ScopedVector<MaskedInstrument> instruments_;
    317 
    318   // The user's shipping addresses.
    319   ScopedVector<Address> addresses_;
    320 
    321   // Legal documents the user must accept before using Online Wallet.
    322   ScopedVector<LegalDocument> legal_documents_;
    323 
    324   // Country codes for allowed Wallet shipping destinations.
    325   std::set<std::string> allowed_shipping_countries_;
    326 
    327   // Whether Google Wallet allows American Express card for this merchant.
    328   AmexPermission amex_permission_;
    329 
    330   DISALLOW_COPY_AND_ASSIGN(WalletItems);
    331 };
    332 
    333 }  // namespace wallet
    334 }  // namespace autofill
    335 
    336 #endif  // COMPONENTS_AUTOFILL_CONTENT_BROWSER_WALLET_WALLET_ITEMS_H_
    337