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