tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

PaymentActionResponse.cpp (11624B)

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