path: root/src/backend/taler-merchant-httpd_private-get-orders-ID.c

/*
  This file is part of TALER
  (C) 2017, 2019, 2020 Taler Systems SA

  TALER is free software; you can redistribute it and/or modify it under the
  terms of the GNU General Public License as published by the Free Software
  Foundation; either version 3, or (at your option) any later version.

  TALER is distributed in the hope that it will be useful, but WITHOUT ANY
  WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with
  TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
*/
/**
 * @file backend/taler-merchant-httpd_private-get-orders-ID.c
 * @brief implementation of GET /private/orders/ID handler
 * @author Florian Dold
 * @author Christian Grothoff
 */
#include "platform.h"
#include "taler-merchant-httpd_private-get-orders-ID.h"
#include <taler/taler_json_lib.h>
#include "taler-merchant-httpd_mhd.h"


/**
 * Data structure we keep for a check payment request.
 */
struct GetOrderRequestContext
{

  /**
   * Entry in the #resume_timeout_heap for this check payment, if we are
   * suspended.
   */
  struct TMH_SuspendedConnection sc;

  /**
   * Which merchant instance is this for?
   */
  struct TMH_HandlerContext *hc;

  /**
   * session of the client
   */
  const char *session_id;

  /**
   * Fulfillment URL extracted from the contract. For repurchase detection.
   * Only valid as long as @e contract_terms is valid!
   */
  const char *fulfillment_url;

  /**
   * Contract terms of the payment we are checking. NULL when they
   * are not (yet) known.
   */
  json_t *contract_terms;

  /**
   * Serial ID of the order.
   */
  uint64_t order_serial;

  /**
   * Total refunds granted for this payment. Only initialized
   * if @e refunded is set to true.
   */
  struct TALER_Amount refund_amount;

  /**
   * Set to true if this payment has been refunded and
   * @e refund_amount is initialized.
   */
  bool refunded;

  /**
   * Did the client request us to fetch the wire transfer status?
   * If false, we may still return it if it is available.
   */
  bool transfer_status_requested;

};


/**
 * Clean up the session state for a GET /private/order/ID request.
 *
 * @param cls closure, must be a `struct GetOrderRequestContext *`
 */
static void
gorc_cleanup (void *cls)
{
  struct GetOrderRequestContext *gorc = cls;

  if (NULL != gorc->contract_terms)
    json_decref (gorc->contract_terms);
  GNUNET_free (gorc);
}


/**
 * Function called with information about a refund.
 * It is responsible for summing up the refund amount.
 *
 * @param cls closure
 * @param coin_pub public coin from which the refund comes from
 * @param exchange_url URL of the exchange that issued @a coin_pub
 * @param rtransaction_id identificator of the refund
 * @param reason human-readable explanation of the refund
 * @param refund_amount refund amount which is being taken from @a coin_pub
 * @param refund_fee cost of this refund operation
 */
static void
process_refunds_cb (void *cls,
                    const struct TALER_CoinSpendPublicKeyP *coin_pub,
                    const char *exchange_url,
                    uint64_t rtransaction_id,
                    const char *reason,
                    const struct TALER_Amount *refund_amount,
                    const struct TALER_Amount *refund_fee)
{
  struct GetOrderRequestContext *gorc = cls;

  // FIXME: probably should do more here and compute
  // an array with the details on the refunds with the reasons;
  // FIXME: spec does NOT mandate that yet!
  if (gorc->refunded)
  {
    GNUNET_assert (0 <=
                   TALER_amount_add (&gorc->refund_amount,
                                     &gorc->refund_amount,
                                     refund_amount));
    return;
  }
  gorc->refund_amount = *refund_amount;
  gorc->refunded = true;
}


/**
 * Manages a GET /private/orders/ID call, checking the status of a payment and
 * refunds and, if necessary, constructing the URL for a payment redirect URL.
 *
 * @param rh context of the handler
 * @param connection the MHD connection to handle
 * @param[in,out] hc context with further information about the request
 * @return MHD result code
 */
MHD_RESULT
TMH_private_get_orders_ID (const struct TMH_RequestHandler *rh,
                           struct MHD_Connection *connection,
                           struct TMH_HandlerContext *hc)
{
  struct GetOrderRequestContext *gorc = hc->ctx;
  enum GNUNET_DB_QueryStatus qs;

  if (NULL == gorc)
  {
    /* First time here, parse request and check order is known */
    gorc = GNUNET_new (struct GetOrderRequestContext);
    hc->cc = &gorc_cleanup;
    hc->ctx = gorc;
    gorc->sc.con = connection;
    gorc->hc = hc;
    GNUNET_assert (NULL != hc->infix);
    gorc->session_id = MHD_lookup_connection_value (connection,
                                                    MHD_GET_ARGUMENT_KIND,
                                                    "session_id");
    {
      const char *long_poll_timeout_s;

      long_poll_timeout_s = MHD_lookup_connection_value (connection,
                                                         MHD_GET_ARGUMENT_KIND,
                                                         "timeout_ms");
      if (NULL != long_poll_timeout_s)
      {
        unsigned long long timeout;

        if (1 != sscanf (long_poll_timeout_s,
                         "%llu",
                         &timeout))
        {
          GNUNET_break_op (0);
          return TALER_MHD_reply_with_error (connection,
                                             MHD_HTTP_BAD_REQUEST,
                                             TALER_EC_PARAMETER_MALFORMED,
                                             "timeout must be non-negative number");
        }
        gorc->sc.long_poll_timeout
          = GNUNET_TIME_relative_to_absolute (GNUNET_TIME_relative_multiply (
                                                GNUNET_TIME_UNIT_MILLISECONDS,
                                                timeout));
      }
      else
      {
        gorc->sc.long_poll_timeout = GNUNET_TIME_UNIT_ZERO_ABS;
      }
    }

    {
      const char *transfer_s;

      transfer_s = MHD_lookup_connection_value (connection,
                                                MHD_GET_ARGUMENT_KIND,
                                                "transfer");
      if ( (NULL != transfer_s) &&
           (0 == strcasecmp (transfer_s,
                             "yes")) )
        gorc->transfer_status_requested = true;
    }
    GNUNET_log (GNUNET_ERROR_TYPE_INFO,
                "Starting GET /private/orders/%s processing with timeout %s\n",
                hc->infix,
                GNUNET_STRINGS_absolute_time_to_string (
                  gorc->sc.long_poll_timeout));

    TMH_db->preflight (TMH_db->cls);
    qs = TMH_db->lookup_contract_terms (TMH_db->cls,
                                        hc->instance.settings->id,
                                        hc->infix,
                                        &gorc->contract_terms,
                                        &gorc->order_serial);
    if (0 > qs)
    {
      /* single, read-only SQL statements should never cause
         serialization problems */
      GNUNET_break (GNUNET_DB_STATUS_SOFT_ERROR != qs);
      /* Always report on hard error as well to enable diagnostics */
      GNUNET_break (GNUNET_DB_STATUS_HARD_ERROR == qs);
      return TALER_MHD_reply_with_error (connection,
                                         MHD_HTTP_INTERNAL_SERVER_ERROR,
                                         TALER_EC_CHECK_PAYMENT_DB_FETCH_CONTRACT_TERMS_ERROR,
                                         "db error fetching contract terms");
    }
    // FIXME: handle qs!
    // => mainly: if 0 return 404!


    /* extract the fulfillment URL from the contract terms! */
    {
      struct GNUNET_JSON_Specification spec[] = {
        GNUNET_JSON_spec_string ("fulfillment_url",
                                 &gorc->fulfillment_url),
        GNUNET_JSON_spec_end ()
      };

      if (GNUNET_OK !=
          GNUNET_JSON_parse (gorc->contract_terms,
                             spec,
                             NULL, NULL))
      {
        GNUNET_break (0);
        return TALER_MHD_reply_with_error (
          connection,
          MHD_HTTP_INTERNAL_SERVER_ERROR,
          TALER_EC_CHECK_PAYMENT_DB_FETCH_CONTRACT_TERMS_ERROR,
          "Merchant database error (contract terms corrupted)");
      }
    }
  }

  GNUNET_assert (NULL != gorc->contract_terms);

  {
    bool paid;
    bool wired;

    TMH_db->preflight (TMH_db->cls);
    qs = TMH_db->lookup_payment_status (TMH_db->cls,
                                        gorc->order_serial,
                                        gorc->session_id,
                                        &paid,
                                        &wired);
    if (0 >= qs)
    {
      /* single, read-only SQL statements should never cause
         serialization problems, and the entry should exist as per above */
      GNUNET_break (GNUNET_DB_STATUS_HARD_ERROR == qs);
      return TALER_MHD_reply_with_error (connection,
                                         MHD_HTTP_INTERNAL_SERVER_ERROR,
                                         TALER_EC_CHECK_PAYMENT_DB_FETCH_PAYMENT_STATUS,
                                         "DB error fetching payment status");
    }
    if (! paid)
    {
      char *already_paid_order_id;

      qs = TMH_db->lookup_order_by_fulfillment (TMH_db->cls,
                                                hc->instance->settings.id,
                                                gorc->fulfillment_url,
                                                gorc->session_id,
                                                &already_paid_order_id);
      if (0 > qs)
      {
        /* single, read-only SQL statements should never cause
           serialization problems, and the entry should exist as per above */
        GNUNET_break (GNUNET_DB_STATUS_HARD_ERROR == qs);
        return TALER_MHD_reply_with_error (connection,
                                           MHD_HTTP_INTERNAL_SERVER_ERROR,
                                           TALER_EC_CHECK_PAYMENT_DB_FETCH_PAYMENT_STATUS,
                                           "DB error fetching payment status");
      }
      if (GNUNET_DB_STATUS_SUCCESS_ONE_RESULT == qs)
      {
        /* User did pay for this order, but under a different session; ask wallet
           to switch order ID */
        char *taler_pay_uri;
        MHD_RESULT ret;

        taler_pay_uri = TMH_make_taler_pay_uri (connection,
                                                hc->infix,
                                                gorc->session_id,
                                                hc->instance.settings->id);
        ret = TALER_MHD_reply_json_pack (connection,
                                         MHD_HTTP_OK,
                                         "{s:s, s:b, s:s}",
                                         "taler_pay_uri",
                                         taler_pay_uri,
                                         "paid",
                                         false,
                                         "already_paid_order_id",
                                         already_paid_order_id);
        GNUNET_free (taler_pay_uri);
        GNUNET_free (already_paid_order_id);
        return ret;
      }
    }

    if (paid &&
        (! wired) &&
        gorc->transfer_status_requested)
    {
      // FIXME: suspend connection, go to exhange to ask for the
      // wire transfer status, and resume once we have it!
      // (make sure to set gorc->transfer_status_requested to FALSE
      // while we are at it!)
      return MHD_YES;
    }

    if ( (! paid) &&
         (0 != gorc.sc.long_poll_timeout.abs_value_us) )
    {
      // FIXME: suspend connection, wait for payment!
      return MHD_YES;
    }

    if (! paid)
    {
      /* User never paid for this order */
      char *taler_pay_uri;
      MHD_RESULT ret;

      taler_pay_uri = TMH_make_taler_pay_uri (connection,
                                              hc->infix,
                                              gorc->session_id,
                                              hc->instance.settings->id);
      ret = TALER_MHD_reply_json_pack (connection,
                                       MHD_HTTP_OK,
                                       "{s:s, s:b}",
                                       "taler_pay_uri",
                                       taler_pay_uri,
                                       "paid",
                                       false);
      GNUNET_free (taler_pay_uri);
      return ret;
    }

    /* Here we know the user DID pay, compute refunds... */

    /* Accumulate refunds, if any. */
    {
      struct GNUNET_HashCode h_contract_terms;

      // FIXME: init h_contract_terms!
      qs = TMH_db->lookup_refunds (TMH_db->cls,
                                   hc->instance.settings->id,
                                   &h_contract_terms,
                                   &process_refunds_cb,
                                   gorc);
    }
    if (0 > qs)
    {
      GNUNET_break (0);
      return TALER_MHD_reply_with_error (connection,
                                         MHD_HTTP_INTERNAL_SERVER_ERROR,
                                         TALER_EC_PAY_DB_FETCH_TRANSACTION_ERROR,
                                         "Merchant database error");
    }
  } /* end of scope of 'paid/wired' */

  /* Generate final reply, including wire details if we have them */
  {
    json_t *wire_details = NULL;

#if FIXME
    qs = TMH_db->select_wire_details_by_order (TMH_db->cls,
                                               gorc->order_serial,
                                               &process_wire_details,
                                               &wire_details);
#endif
    if (0 > qs)
    {
      GNUNET_break (0);
      return TALER_MHD_reply_with_error (connection,
                                         MHD_HTTP_INTERNAL_SERVER_ERROR,
                                         TALER_EC_PAY_DB_FETCH_TRANSACTION_ERROR,
                                         "Merchant database error");
    }
    return TALER_MHD_reply_json_pack (connection,
                                      MHD_HTTP_OK,
                                      "{s:O, s:b, s:b, s:o?, s:o?}",
                                      "contract_terms",
                                      gorc->contract_terms,
                                      "paid",
                                      true,
                                      "refunded",
                                      gorc->refunded,
                                      "refund_amount",
                                      (gorc->refunded)
                                      ? TALER_JSON_from_amount (
                                        &gorc->refund_amount)
                                      : NULL,
                                      "wire_details",
                                      wire_details);
  }
}