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
22namespace base {
23class DictionaryValue;
24}
25
26namespace gfx {
27class Image;
28}
29
30namespace autofill {
31
32class AutofillType;
33
34FORWARD_DECLARE_TEST(WalletInstrumentWrapperTest, GetInfoCreditCardExpMonth);
35FORWARD_DECLARE_TEST(WalletInstrumentWrapperTest,
36                     GetDisplayTextEmptyWhenExpired);
37
38namespace wallet {
39
40class GaiaAccount;
41class WalletItemsTest;
42
43enum 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.
53class 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