dom/payments/PaymentActionResponse.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "PaymentActionResponse.h"
   8 #include "BasicCardPayment.h"
   9 #include "PaymentRequestUtils.h"
  10
  11 namespace mozilla::dom {
  12
  13 /* PaymentResponseData */
  14
  15 NS_IMPL_ISUPPORTS(PaymentResponseData, nsIPaymentResponseData)
  16
  17 NS_IMETHODIMP
  18 PaymentResponseData::GetType(uint32_t* aType) {
  19   NS_ENSURE_ARG_POINTER(aType);
  20   *aType = mType;
  21   return NS_OK;
  22 }
  23
  24 NS_IMETHODIMP
  25 PaymentResponseData::Init(const uint32_t aType) {
  26   if (aType != nsIPaymentResponseData::GENERAL_RESPONSE &&
  27       aType != nsIPaymentResponseData::BASICCARD_RESPONSE) {
  28     return NS_ERROR_FAILURE;
  29   }
  30   mType = aType;
  31   return NS_OK;
  32 }
  33
  34 /* GeneralResponseData */
  35
  36 NS_IMPL_ISUPPORTS_INHERITED(GeneralResponseData, PaymentResponseData,
  37                             nsIGeneralResponseData)
  38
  39 GeneralResponseData::GeneralResponseData() : mData(u"{}"_ns) {
  40   Init(nsIPaymentResponseData::GENERAL_RESPONSE);
  41 }
  42
  43 NS_IMETHODIMP
  44 GeneralResponseData::GetData(nsAString& aData) {
  45   aData = mData;
  46   return NS_OK;
  47 }
  48
  49 NS_IMETHODIMP
  50 GeneralResponseData::InitData(JS::Handle<JS::Value> aValue, JSContext* aCx) {
  51   if (aValue.isNullOrUndefined()) {
  52     return NS_ERROR_FAILURE;
  53   }
  54   nsresult rv = SerializeFromJSVal(aCx, aValue, mData);
  55   if (NS_WARN_IF(NS_FAILED(rv))) {
  56     return rv;
  57   }
  58   return NS_OK;
  59 }
  60
  61 /* BasicCardResponseData */
  62
  63 NS_IMPL_ISUPPORTS_INHERITED(BasicCardResponseData, PaymentResponseData,
  64                             nsIBasicCardResponseData)
  65
  66 BasicCardResponseData::BasicCardResponseData() {
  67   Init(nsIPaymentResponseData::BASICCARD_RESPONSE);
  68 }
  69
  70 NS_IMETHODIMP
  71 BasicCardResponseData::GetCardholderName(nsAString& aCardholderName) {
  72   aCardholderName = mCardholderName;
  73   return NS_OK;
  74 }
  75
  76 NS_IMETHODIMP
  77 BasicCardResponseData::GetCardNumber(nsAString& aCardNumber) {
  78   aCardNumber = mCardNumber;
  79   return NS_OK;
  80 }
  81
  82 NS_IMETHODIMP
  83 BasicCardResponseData::GetExpiryMonth(nsAString& aExpiryMonth) {
  84   aExpiryMonth = mExpiryMonth;
  85   return NS_OK;
  86 }
  87
  88 NS_IMETHODIMP
  89 BasicCardResponseData::GetExpiryYear(nsAString& aExpiryYear) {
  90   aExpiryYear = mExpiryYear;
  91   return NS_OK;
  92 }
  93
  94 NS_IMETHODIMP
  95 BasicCardResponseData::GetCardSecurityCode(nsAString& aCardSecurityCode) {
  96   aCardSecurityCode = mCardSecurityCode;
  97   return NS_OK;
  98 }
  99
 100 NS_IMETHODIMP
 101 BasicCardResponseData::GetBillingAddress(nsIPaymentAddress** aBillingAddress) {
 102   NS_ENSURE_ARG_POINTER(aBillingAddress);
 103   nsCOMPtr<nsIPaymentAddress> address;
 104   address = mBillingAddress;
 105   address.forget(aBillingAddress);
 106   return NS_OK;
 107 }
 108
 109 NS_IMETHODIMP
 110 BasicCardResponseData::InitData(const nsAString& aCardholderName,
 111                                 const nsAString& aCardNumber,
 112                                 const nsAString& aExpiryMonth,
 113                                 const nsAString& aExpiryYear,
 114                                 const nsAString& aCardSecurityCode,
 115                                 nsIPaymentAddress* aBillingAddress) {
 116   // cardNumber is a required attribute, cannot be empty;
 117   if (aCardNumber.IsEmpty()) {
 118     return NS_ERROR_FAILURE;
 119   }
 120
 121   RefPtr<BasicCardService> service = BasicCardService::GetService();
 122   MOZ_ASSERT(service);
 123
 124   if (!service->IsValidExpiryMonth(aExpiryMonth)) {
 125     return NS_ERROR_FAILURE;
 126   }
 127
 128   if (!service->IsValidExpiryYear(aExpiryYear)) {
 129     return NS_ERROR_FAILURE;
 130   }
 131
 132   mCardholderName = aCardholderName;
 133   mCardNumber = aCardNumber;
 134   mExpiryMonth = aExpiryMonth;
 135   mExpiryYear = aExpiryYear;
 136   mCardSecurityCode = aCardSecurityCode;
 137   mBillingAddress = aBillingAddress;
 138
 139   return NS_OK;
 140 }
 141
 142 /* PaymentActionResponse */
 143
 144 NS_IMPL_ISUPPORTS(PaymentActionResponse, nsIPaymentActionResponse)
 145
 146 PaymentActionResponse::PaymentActionResponse()
 147     : mRequestId(u""_ns), mType(nsIPaymentActionResponse::NO_TYPE) {}
 148
 149 NS_IMETHODIMP
 150 PaymentActionResponse::GetRequestId(nsAString& aRequestId) {
 151   aRequestId = mRequestId;
 152   return NS_OK;
 153 }
 154
 155 NS_IMETHODIMP
 156 PaymentActionResponse::GetType(uint32_t* aType) {
 157   NS_ENSURE_ARG_POINTER(aType);
 158   *aType = mType;
 159   return NS_OK;
 160 }
 161
 162 /* PaymentCanMakeActionResponse */
 163
 164 NS_IMPL_ISUPPORTS_INHERITED(PaymentCanMakeActionResponse, PaymentActionResponse,
 165                             nsIPaymentCanMakeActionResponse)
 166
 167 PaymentCanMakeActionResponse::PaymentCanMakeActionResponse() : mResult(false) {
 168   mType = nsIPaymentActionResponse::CANMAKE_ACTION;
 169 }
 170
 171 NS_IMETHODIMP
 172 PaymentCanMakeActionResponse::GetResult(bool* aResult) {
 173   NS_ENSURE_ARG_POINTER(aResult);
 174   *aResult = mResult;
 175   return NS_OK;
 176 }
 177
 178 NS_IMETHODIMP
 179 PaymentCanMakeActionResponse::Init(const nsAString& aRequestId,
 180                                    const bool aResult) {
 181   mRequestId = aRequestId;
 182   mResult = aResult;
 183   return NS_OK;
 184 }
 185
 186 /* PaymentShowActionResponse */
 187
 188 NS_IMPL_ISUPPORTS_INHERITED(PaymentShowActionResponse, PaymentActionResponse,
 189                             nsIPaymentShowActionResponse)
 190
 191 PaymentShowActionResponse::PaymentShowActionResponse()
 192     : mAcceptStatus(nsIPaymentActionResponse::PAYMENT_REJECTED) {
 193   mType = nsIPaymentActionResponse::SHOW_ACTION;
 194 }
 195
 196 NS_IMETHODIMP
 197 PaymentShowActionResponse::GetAcceptStatus(uint32_t* aAcceptStatus) {
 198   NS_ENSURE_ARG_POINTER(aAcceptStatus);
 199   *aAcceptStatus = mAcceptStatus;
 200   return NS_OK;
 201 }
 202
 203 NS_IMETHODIMP
 204 PaymentShowActionResponse::GetMethodName(nsAString& aMethodName) {
 205   aMethodName = mMethodName;
 206   return NS_OK;
 207 }
 208
 209 NS_IMETHODIMP
 210 PaymentShowActionResponse::GetData(nsIPaymentResponseData** aData) {
 211   NS_ENSURE_ARG_POINTER(aData);
 212   nsCOMPtr<nsIPaymentResponseData> data = mData;
 213   data.forget(aData);
 214   return NS_OK;
 215 }
 216
 217 NS_IMETHODIMP
 218 PaymentShowActionResponse::GetPayerName(nsAString& aPayerName) {
 219   aPayerName = mPayerName;
 220   return NS_OK;
 221 }
 222
 223 NS_IMETHODIMP
 224 PaymentShowActionResponse::GetPayerEmail(nsAString& aPayerEmail) {
 225   aPayerEmail = mPayerEmail;
 226   return NS_OK;
 227 }
 228
 229 NS_IMETHODIMP
 230 PaymentShowActionResponse::GetPayerPhone(nsAString& aPayerPhone) {
 231   aPayerPhone = mPayerPhone;
 232   return NS_OK;
 233 }
 234
 235 NS_IMETHODIMP
 236 PaymentShowActionResponse::Init(const nsAString& aRequestId,
 237                                 const uint32_t aAcceptStatus,
 238                                 const nsAString& aMethodName,
 239                                 nsIPaymentResponseData* aData,
 240                                 const nsAString& aPayerName,
 241                                 const nsAString& aPayerEmail,
 242                                 const nsAString& aPayerPhone) {
 243   if (aAcceptStatus == nsIPaymentActionResponse::PAYMENT_ACCEPTED) {
 244     NS_ENSURE_ARG_POINTER(aData);
 245   }
 246
 247   mRequestId = aRequestId;
 248   mAcceptStatus = aAcceptStatus;
 249   mMethodName = aMethodName;
 250
 251   RefPtr<BasicCardService> service = BasicCardService::GetService();
 252   MOZ_ASSERT(service);
 253   bool isBasicCardPayment = service->IsBasicCardPayment(mMethodName);
 254
 255   if (aAcceptStatus == nsIPaymentActionResponse::PAYMENT_ACCEPTED) {
 256     uint32_t responseType;
 257     NS_ENSURE_SUCCESS(aData->GetType(&responseType), NS_ERROR_FAILURE);
 258     switch (responseType) {
 259       case nsIPaymentResponseData::GENERAL_RESPONSE: {
 260         if (isBasicCardPayment) {
 261           return NS_ERROR_FAILURE;
 262         }
 263         break;
 264       }
 265       case nsIPaymentResponseData::BASICCARD_RESPONSE: {
 266         if (!isBasicCardPayment) {
 267           return NS_ERROR_FAILURE;
 268         }
 269         break;
 270       }
 271       default: {
 272         return NS_ERROR_FAILURE;
 273       }
 274     }
 275   }
 276   mData = aData;
 277   mPayerName = aPayerName;
 278   mPayerEmail = aPayerEmail;
 279   mPayerPhone = aPayerPhone;
 280   return NS_OK;
 281 }
 282
 283 /* PaymentAbortActionResponse */
 284
 285 NS_IMPL_ISUPPORTS_INHERITED(PaymentAbortActionResponse, PaymentActionResponse,
 286                             nsIPaymentAbortActionResponse)
 287
 288 PaymentAbortActionResponse::PaymentAbortActionResponse()
 289     : mAbortStatus(nsIPaymentActionResponse::ABORT_FAILED) {
 290   mType = nsIPaymentActionResponse::ABORT_ACTION;
 291 }
 292
 293 NS_IMETHODIMP
 294 PaymentAbortActionResponse::GetAbortStatus(uint32_t* aAbortStatus) {
 295   NS_ENSURE_ARG_POINTER(aAbortStatus);
 296   *aAbortStatus = mAbortStatus;
 297   return NS_OK;
 298 }
 299
 300 NS_IMETHODIMP
 301 PaymentAbortActionResponse::Init(const nsAString& aRequestId,
 302                                  const uint32_t aAbortStatus) {
 303   mRequestId = aRequestId;
 304   mAbortStatus = aAbortStatus;
 305   return NS_OK;
 306 }
 307
 308 NS_IMETHODIMP
 309 PaymentAbortActionResponse::IsSucceeded(bool* aIsSucceeded) {
 310   NS_ENSURE_ARG_POINTER(aIsSucceeded);
 311   *aIsSucceeded = (mAbortStatus == nsIPaymentActionResponse::ABORT_SUCCEEDED);
 312   return NS_OK;
 313 }
 314
 315 /* PaymentCompleteActionResponse */
 316
 317 NS_IMPL_ISUPPORTS_INHERITED(PaymentCompleteActionResponse,
 318                             PaymentActionResponse,
 319                             nsIPaymentCompleteActionResponse)
 320
 321 PaymentCompleteActionResponse::PaymentCompleteActionResponse()
 322     : mCompleteStatus(nsIPaymentActionResponse::COMPLETE_FAILED) {
 323   mType = nsIPaymentActionResponse::COMPLETE_ACTION;
 324 }
 325
 326 nsresult PaymentCompleteActionResponse::Init(const nsAString& aRequestId,
 327                                              const uint32_t aCompleteStatus) {
 328   mRequestId = aRequestId;
 329   mCompleteStatus = aCompleteStatus;
 330   return NS_OK;
 331 }
 332
 333 nsresult PaymentCompleteActionResponse::GetCompleteStatus(
 334     uint32_t* aCompleteStatus) {
 335   NS_ENSURE_ARG_POINTER(aCompleteStatus);
 336   *aCompleteStatus = mCompleteStatus;
 337   return NS_OK;
 338 }
 339
 340 nsresult PaymentCompleteActionResponse::IsCompleted(bool* aIsCompleted) {
 341   NS_ENSURE_ARG_POINTER(aIsCompleted);
 342   *aIsCompleted =
 343       (mCompleteStatus == nsIPaymentActionResponse::COMPLETE_SUCCEEDED);
 344   return NS_OK;
 345 }
 346
 347 /* PaymentChangeDetails */
 348
 349 NS_IMPL_ISUPPORTS(MethodChangeDetails, nsIMethodChangeDetails)
 350
 351 NS_IMETHODIMP
 352 MethodChangeDetails::GetType(uint32_t* aType) {
 353   NS_ENSURE_ARG_POINTER(aType);
 354   *aType = mType;
 355   return NS_OK;
 356 }
 357
 358 NS_IMETHODIMP
 359 MethodChangeDetails::Init(const uint32_t aType) {
 360   if (aType != nsIMethodChangeDetails::GENERAL_DETAILS &&
 361       aType != nsIMethodChangeDetails::BASICCARD_DETAILS) {
 362     return NS_ERROR_FAILURE;
 363   }
 364   mType = aType;
 365   return NS_OK;
 366 }
 367
 368 /* GeneralMethodChangeDetails */
 369
 370 NS_IMPL_ISUPPORTS_INHERITED(GeneralMethodChangeDetails, MethodChangeDetails,
 371                             nsIGeneralChangeDetails)
 372
 373 GeneralMethodChangeDetails::GeneralMethodChangeDetails() : mDetails(u"{}"_ns) {
 374   Init(nsIMethodChangeDetails::GENERAL_DETAILS);
 375 }
 376
 377 NS_IMETHODIMP
 378 GeneralMethodChangeDetails::GetDetails(nsAString& aDetails) {
 379   aDetails = mDetails;
 380   return NS_OK;
 381 }
 382
 383 NS_IMETHODIMP
 384 GeneralMethodChangeDetails::InitData(JS::Handle<JS::Value> aDetails,
 385                                      JSContext* aCx) {
 386   if (aDetails.isNullOrUndefined()) {
 387     return NS_ERROR_FAILURE;
 388   }
 389   nsresult rv = SerializeFromJSVal(aCx, aDetails, mDetails);
 390   if (NS_WARN_IF(NS_FAILED(rv))) {
 391     return rv;
 392   }
 393   return NS_OK;
 394 }
 395
 396 /* BasicCardMethodChangeDetails */
 397
 398 NS_IMPL_ISUPPORTS_INHERITED(BasicCardMethodChangeDetails, MethodChangeDetails,
 399                             nsIBasicCardChangeDetails)
 400
 401 BasicCardMethodChangeDetails::BasicCardMethodChangeDetails() {
 402   Init(nsIMethodChangeDetails::BASICCARD_DETAILS);
 403 }
 404
 405 NS_IMETHODIMP
 406 BasicCardMethodChangeDetails::GetBillingAddress(
 407     nsIPaymentAddress** aBillingAddress) {
 408   NS_ENSURE_ARG_POINTER(aBillingAddress);
 409   nsCOMPtr<nsIPaymentAddress> address;
 410   address = mBillingAddress;
 411   address.forget(aBillingAddress);
 412   return NS_OK;
 413 }
 414
 415 NS_IMETHODIMP
 416 BasicCardMethodChangeDetails::InitData(nsIPaymentAddress* aBillingAddress) {
 417   mBillingAddress = aBillingAddress;
 418   return NS_OK;
 419 }
 420
 421 }  // namespace mozilla::dom