LCOV - code coverage report
Current view: top level - lib - merchant_api_post_orders.c (source / functions) Hit Total Coverage
Test: GNU Taler merchant coverage report Lines: 0 116 0.0 %
Date: 2022-08-25 06:17:04 Functions: 0 4 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   This file is part of TALER
       3             :   Copyright (C) 2014-2021 Taler Systems SA
       4             : 
       5             :   TALER is free software; you can redistribute it and/or modify
       6             :   it under the terms of the GNU Lesser General Public License as
       7             :   published by the Free Software Foundation; either version 2.1,
       8             :   or (at your option) any later version.
       9             : 
      10             :   TALER is distributed in the hope that it will be useful, but
      11             :   WITHOUT ANY WARRANTY; without even the implied warranty of
      12             :   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      13             :   GNU Lesser General Public License for more details.
      14             : 
      15             :   You should have received a copy of the GNU Lesser General Public
      16             :   License along with TALER; see the file COPYING.LGPL.  If not,
      17             :   see <http://www.gnu.org/licenses/>
      18             : */
      19             : /**
      20             :  * @file merchant_api_post_orders.c
      21             :  * @brief Implementation of the POST /orders
      22             :  * @author Christian Grothoff
      23             :  * @author Marcello Stanisci
      24             :  */
      25             : #include "platform.h"
      26             : #include <curl/curl.h>
      27             : #include <jansson.h>
      28             : #include <microhttpd.h> /* just for HTTP status codes */
      29             : #include <gnunet/gnunet_util_lib.h>
      30             : #include <gnunet/gnunet_curl_lib.h>
      31             : #include "taler_merchant_service.h"
      32             : #include "merchant_api_curl_defaults.h"
      33             : #include <taler/taler_json_lib.h>
      34             : #include <taler/taler_signatures.h>
      35             : #include <taler/taler_curl_lib.h>
      36             : 
      37             : 
      38             : /**
      39             :  * @brief A POST /orders Handle
      40             :  */
      41             : struct TALER_MERCHANT_PostOrdersHandle
      42             : {
      43             : 
      44             :   /**
      45             :    * The url for this request.
      46             :    */
      47             :   char *url;
      48             : 
      49             :   /**
      50             :    * Handle for the request.
      51             :    */
      52             :   struct GNUNET_CURL_Job *job;
      53             : 
      54             :   /**
      55             :    * Function to call with the result.
      56             :    */
      57             :   TALER_MERCHANT_PostOrdersCallback cb;
      58             : 
      59             :   /**
      60             :    * Closure for @a cb.
      61             :    */
      62             :   void *cb_cls;
      63             : 
      64             :   /**
      65             :    * Reference to the execution context.
      66             :    */
      67             :   struct GNUNET_CURL_Context *ctx;
      68             : 
      69             :   /**
      70             :    * Minor context that holds body and headers.
      71             :    */
      72             :   struct TALER_CURL_PostContext post_ctx;
      73             : };
      74             : 
      75             : 
      76             : /**
      77             :  * Function called when we're done processing the
      78             :  * HTTP POST /orders request.
      79             :  *
      80             :  * @param cls the `struct TALER_MERCHANT_PostOrdersHandle`
      81             :  * @param response_code HTTP response code, 0 on error
      82             :  * @param response response body, NULL if not JSON
      83             :  */
      84             : static void
      85           0 : handle_post_order_finished (void *cls,
      86             :                             long response_code,
      87             :                             const void *response)
      88             : {
      89           0 :   struct TALER_MERCHANT_PostOrdersHandle *po = cls;
      90           0 :   const json_t *json = response;
      91           0 :   struct TALER_MERCHANT_PostOrdersReply por = {
      92           0 :     .hr.http_status = (unsigned int) response_code,
      93             :     .hr.reply = json
      94             :   };
      95             :   struct TALER_ClaimTokenP token;
      96             : 
      97           0 :   po->job = NULL;
      98           0 :   switch (response_code)
      99             :   {
     100           0 :   case 0:
     101           0 :     por.hr.ec = TALER_EC_GENERIC_INVALID_RESPONSE;
     102           0 :     break;
     103           0 :   case MHD_HTTP_OK:
     104             :     {
     105             :       bool no_token;
     106             :       struct GNUNET_JSON_Specification spec[] = {
     107           0 :         GNUNET_JSON_spec_string ("order_id",
     108             :                                  &por.details.ok.order_id),
     109           0 :         GNUNET_JSON_spec_mark_optional (
     110             :           GNUNET_JSON_spec_fixed_auto ("token",
     111             :                                        &token),
     112             :           &no_token),
     113           0 :         GNUNET_JSON_spec_end ()
     114             :       };
     115             : 
     116           0 :       if (GNUNET_OK !=
     117           0 :           GNUNET_JSON_parse (json,
     118             :                              spec,
     119             :                              NULL, NULL))
     120             :       {
     121           0 :         GNUNET_break_op (0);
     122           0 :         por.hr.http_status = 0;
     123           0 :         por.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
     124             :       }
     125             :       else
     126             :       {
     127           0 :         if (! no_token)
     128           0 :           por.details.ok.token = &token;
     129             :       }
     130             :     }
     131           0 :     break;
     132           0 :   case MHD_HTTP_BAD_REQUEST:
     133           0 :     json_dumpf (json,
     134             :                 stderr,
     135             :                 JSON_INDENT (2));
     136           0 :     por.hr.ec = TALER_JSON_get_error_code (json);
     137           0 :     por.hr.hint = TALER_JSON_get_error_hint (json);
     138             :     /* This should never happen, either us or
     139             :        the merchant is buggy (or API version conflict);
     140             :        just pass JSON reply to the application */
     141           0 :     break;
     142           0 :   case MHD_HTTP_UNAUTHORIZED:
     143           0 :     por.hr.ec = TALER_JSON_get_error_code (json);
     144           0 :     por.hr.hint = TALER_JSON_get_error_hint (json);
     145             :     /* Nothing really to verify, merchant says we need to authenticate. */
     146           0 :     break;
     147           0 :   case MHD_HTTP_FORBIDDEN:
     148             :     /* Nothing really to verify, merchant says one
     149             :        of the signatures is invalid; as we checked them,
     150             :        this should never happen, we should pass the JSON
     151             :        reply to the application */
     152           0 :     por.hr.ec = TALER_JSON_get_error_code (json);
     153           0 :     por.hr.hint = TALER_JSON_get_error_hint (json);
     154           0 :     break;
     155           0 :   case MHD_HTTP_NOT_FOUND:
     156             :     /* Nothing really to verify, this should never
     157             :        happen, we should pass the JSON reply to the application */
     158           0 :     por.hr.ec = TALER_JSON_get_error_code (json);
     159           0 :     por.hr.hint = TALER_JSON_get_error_hint (json);
     160           0 :     break;
     161           0 :   case MHD_HTTP_CONFLICT:
     162           0 :     por.hr.ec = TALER_JSON_get_error_code (json);
     163           0 :     por.hr.hint = TALER_JSON_get_error_hint (json);
     164           0 :     break;
     165           0 :   case MHD_HTTP_GONE:
     166             :     /* The quantity of some product requested was not available. */
     167             :     {
     168             : 
     169             :       struct GNUNET_JSON_Specification spec[] = {
     170           0 :         GNUNET_JSON_spec_string (
     171             :           "product_id",
     172             :           &por.details.gone.product_id),
     173           0 :         GNUNET_JSON_spec_uint64 (
     174             :           "requested_quantity",
     175             :           &por.details.gone.requested_quantity),
     176           0 :         GNUNET_JSON_spec_uint64 (
     177             :           "available_quantity",
     178             :           &por.details.gone.available_quantity),
     179           0 :         GNUNET_JSON_spec_mark_optional (
     180             :           GNUNET_JSON_spec_timestamp (
     181             :             "restock_expected",
     182             :             &por.details.gone.restock_expected),
     183             :           NULL),
     184           0 :         GNUNET_JSON_spec_end ()
     185             :       };
     186             : 
     187           0 :       if (GNUNET_OK !=
     188           0 :           GNUNET_JSON_parse (json,
     189             :                              spec,
     190             :                              NULL, NULL))
     191             :       {
     192           0 :         GNUNET_break_op (0);
     193           0 :         por.hr.http_status = 0;
     194           0 :         por.hr.ec = TALER_EC_GENERIC_REPLY_MALFORMED;
     195             :       }
     196           0 :       break;
     197             :     }
     198           0 :   case MHD_HTTP_INTERNAL_SERVER_ERROR:
     199             :     /* Server had an internal issue; we should retry,
     200             :        but this API leaves this to the application */
     201           0 :     por.hr.ec = TALER_JSON_get_error_code (json);
     202           0 :     por.hr.hint = TALER_JSON_get_error_hint (json);
     203           0 :     break;
     204           0 :   default:
     205             :     /* unexpected response code */
     206           0 :     por.hr.ec = TALER_JSON_get_error_code (json);
     207           0 :     por.hr.hint = TALER_JSON_get_error_hint (json);
     208           0 :     GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
     209             :                 "Unexpected response code %u/%d\n",
     210             :                 (unsigned int) response_code,
     211             :                 (int) por.hr.ec);
     212           0 :     GNUNET_break_op (0);
     213           0 :     break;
     214             :   }
     215           0 :   po->cb (po->cb_cls,
     216             :           &por);
     217           0 :   TALER_MERCHANT_orders_post_cancel (po);
     218           0 : }
     219             : 
     220             : 
     221             : struct TALER_MERCHANT_PostOrdersHandle *
     222           0 : TALER_MERCHANT_orders_post (struct GNUNET_CURL_Context *ctx,
     223             :                             const char *backend_url,
     224             :                             const json_t *order,
     225             :                             struct GNUNET_TIME_Relative refund_delay,
     226             :                             TALER_MERCHANT_PostOrdersCallback cb,
     227             :                             void *cb_cls)
     228             : {
     229           0 :   return TALER_MERCHANT_orders_post2 (ctx,
     230             :                                       backend_url,
     231             :                                       order,
     232             :                                       refund_delay,
     233             :                                       NULL,
     234             :                                       0,
     235             :                                       NULL,
     236             :                                       0,
     237             :                                       NULL,
     238             :                                       true,
     239             :                                       cb,
     240             :                                       cb_cls);
     241             : }
     242             : 
     243             : 
     244             : struct TALER_MERCHANT_PostOrdersHandle *
     245           0 : TALER_MERCHANT_orders_post2 (
     246             :   struct GNUNET_CURL_Context *ctx,
     247             :   const char *backend_url,
     248             :   const json_t *order,
     249             :   struct GNUNET_TIME_Relative refund_delay,
     250             :   const char *payment_target,
     251             :   unsigned int inventory_products_length,
     252             :   const struct TALER_MERCHANT_InventoryProduct inventory_products[],
     253             :   unsigned int uuids_length,
     254             :   const char *uuids[],
     255             :   bool create_token,
     256             :   TALER_MERCHANT_PostOrdersCallback cb,
     257             :   void *cb_cls)
     258             : {
     259             :   struct TALER_MERCHANT_PostOrdersHandle *po;
     260             :   json_t *req;
     261             :   CURL *eh;
     262             : 
     263           0 :   po = GNUNET_new (struct TALER_MERCHANT_PostOrdersHandle);
     264           0 :   po->ctx = ctx;
     265           0 :   po->cb = cb;
     266           0 :   po->cb_cls = cb_cls;
     267           0 :   po->url = TALER_url_join (backend_url,
     268             :                             "private/orders",
     269             :                             NULL);
     270           0 :   req = GNUNET_JSON_PACK (
     271             :     GNUNET_JSON_pack_object_incref ("order",
     272             :                                     (json_t *) order),
     273             :     GNUNET_JSON_pack_allow_null (
     274             :       GNUNET_JSON_pack_string ("payment_target",
     275             :                                payment_target)));
     276           0 :   if (0 != refund_delay.rel_value_us)
     277             :   {
     278           0 :     GNUNET_assert (0 ==
     279             :                    json_object_set_new (req,
     280             :                                         "refund_delay",
     281             :                                         GNUNET_JSON_from_time_rel (
     282             :                                           refund_delay)));
     283             :   }
     284           0 :   if (0 != inventory_products_length)
     285             :   {
     286           0 :     json_t *ipa = json_array ();
     287             : 
     288           0 :     GNUNET_assert (NULL != ipa);
     289           0 :     for (unsigned int i = 0; i<inventory_products_length; i++)
     290             :     {
     291             :       json_t *ip;
     292             : 
     293           0 :       ip = GNUNET_JSON_PACK (
     294             :         GNUNET_JSON_pack_string ("product_id",
     295             :                                  inventory_products[i].product_id),
     296             :         GNUNET_JSON_pack_uint64 ("quantity",
     297             :                                  inventory_products[i].quantity));
     298           0 :       GNUNET_assert (NULL != ip);
     299           0 :       GNUNET_assert (0 ==
     300             :                      json_array_append_new (ipa,
     301             :                                             ip));
     302             :     }
     303           0 :     GNUNET_assert (0 ==
     304             :                    json_object_set_new (req,
     305             :                                         "inventory_products",
     306             :                                         ipa));
     307             :   }
     308           0 :   if (0 != uuids_length)
     309             :   {
     310           0 :     json_t *ua = json_array ();
     311             : 
     312           0 :     GNUNET_assert (NULL != ua);
     313           0 :     for (unsigned int i = 0; i<uuids_length; i++)
     314             :     {
     315             :       json_t *u;
     316             : 
     317           0 :       u = json_string (uuids[i]);
     318           0 :       GNUNET_assert (0 ==
     319             :                      json_array_append_new (ua,
     320             :                                             u));
     321             :     }
     322           0 :     GNUNET_assert (0 ==
     323             :                    json_object_set_new (req,
     324             :                                         "lock_uuids",
     325             :                                         ua));
     326             :   }
     327           0 :   if (! create_token)
     328             :   {
     329           0 :     GNUNET_assert (0 ==
     330             :                    json_object_set_new (req,
     331             :                                         "create_token",
     332             :                                         json_boolean (create_token)));
     333             :   }
     334           0 :   eh = TALER_MERCHANT_curl_easy_get_ (po->url);
     335           0 :   if (GNUNET_OK !=
     336           0 :       TALER_curl_easy_post (&po->post_ctx,
     337             :                             eh,
     338             :                             req))
     339             :   {
     340           0 :     GNUNET_break (0);
     341           0 :     curl_easy_cleanup (eh);
     342           0 :     json_decref (req);
     343           0 :     GNUNET_free (po);
     344           0 :     return NULL;
     345             :   }
     346           0 :   json_decref (req);
     347           0 :   po->job = GNUNET_CURL_job_add2 (ctx,
     348             :                                   eh,
     349           0 :                                   po->post_ctx.headers,
     350             :                                   &handle_post_order_finished,
     351             :                                   po);
     352           0 :   return po;
     353             : }
     354             : 
     355             : 
     356             : void
     357           0 : TALER_MERCHANT_orders_post_cancel (
     358             :   struct TALER_MERCHANT_PostOrdersHandle *po)
     359             : {
     360           0 :   if (NULL != po->job)
     361             :   {
     362           0 :     GNUNET_CURL_job_cancel (po->job);
     363           0 :     po->job = NULL;
     364             :   }
     365           0 :   GNUNET_free (po->url);
     366           0 :   TALER_curl_easy_post_finished (&po->post_ctx);
     367           0 :   GNUNET_free (po);
     368           0 : }
     369             : 
     370             : 
     371             : /* end of merchant_api_post_orders.c */

Generated by: LCOV version 1.14