turnstile

TurnstilePriceCategory.php (12872B)

---

 <?php
 
 /**
  * @file
  * Price category structure for the GNU Taler Turnstile module.
  */
 
 namespace Drupal\taler_turnstile\Entity;
 
 use Drupal\Core\Config\Entity\ConfigEntityBase;
 use Drupal\Core\Entity\EntityStorageInterface;
 use Drupal\Core\StringTranslation\StringTranslationTrait;
 use Drupal\taler_turnstile\Amount;
 use Drupal\taler_turnstile\TalerBackendResult;
 
 /**
  * Defines the Price Category entity.
  *
  * @ConfigEntityType(
  *   id = "taler_turnstile_price_category",
  *   label = @Translation("Price Category"),
  *   handlers = {
  *     "list_builder" = "Drupal\taler_turnstile\PriceCategoryListBuilder",
  *     "form" = {
  *       "add" = "Drupal\taler_turnstile\Form\PriceCategoryForm",
  *       "edit" = "Drupal\taler_turnstile\Form\PriceCategoryForm",
  *       "delete" = "Drupal\taler_turnstile\Form\PriceCategoryDeleteForm"
  *     }
  *   },
  *   config_prefix = "taler_turnstile_price_category",
  *   admin_permission = "administer price categories",
  *   entity_keys = {
  *     "id" = "id",
  *     "label" = "label"
  *   },
  *   links = {
  *     "collection" = "/admin/structure/taler-turnstile-price-categories",
  *     "edit-form" = "/admin/structure/taler-turnstile-price-categories/{price_category}/edit",
  *     "delete-form" = "/admin/structure/taler-turnstile-price-categories/{price_category}/delete"
  *   },
  *   config_export = {
  *     "id",
  *     "label",
  *     "description",
  *     "prices"
  *   }
  * )
  */
 class TurnstilePriceCategory extends ConfigEntityBase {
 
   /**
    * For i18n, gives us the t() function.
    */
   use StringTranslationTrait;
 
   /**
    * The price category ID.
    *
    * @var string
    */
   protected $id;
 
   /**
    * The price category label.
    *
    * @var string
    */
   protected $label;
 
   /**
    * The price category description.
    *
    * @var string
    */
   protected $description;
 
   /**
    * The prices array.
    *
    * Structure: ['subscription_id' => ['currency_code' => 'price']]
    *
    * @var array
    */
   protected $prices = [];
 
   /**
    * Result of the most recent merchant-backend sync triggered by
    * postSave() / postDelete() on this entity instance. NULL if no
    * sync has been attempted yet. Read by PriceCategoryForm::save()
    * and PriceCategoryDeleteForm::submitForm() to surface backend
    * failures that would otherwise be silently logged.
    *
    * Not persisted; this property is intentionally not in
    * config_export and not in the schema.
    *
    * @var \Drupal\taler_turnstile\TalerBackendResult|null
    */
   public ?TalerBackendResult $lastSyncResult = NULL;
 
   /**
    * Gets the description.
    *
    * @return string
    *   The description.
    */
   public function getDescription() {
     return $this->description;
   }
 
   /**
    * Compute the merchant template ID used to publish the prices
    * of this category in the merchant backend. Kept short and
    * reasonably distinctive (per the README, "turnstile-$NAME").
    *
    * @return string
    *   Template ID
    */
   public function getTemplateId(): string {
     return 'turnstile-' . $this->id();
   }
 
 
   /**
    * Return the set of "currency:amount" strings that match valid
    * payment amounts for this category. Used to verify that a paid
    * contract actually paid for the right thing.
    *
    * @param array $subscriptions
    *   Live subscription data, as produced by
    *   TalerMerchantApiService::getSubscriptions().
    * @return array<string>
    */
   public function getAcceptableAmounts(array $subscriptions): array {
     $amounts = [];
     foreach ($this->getPaymentChoices($subscriptions) as $choice) {
       if (isset($choice['amount'])) {
         $amounts[] = $choice['amount'];
       }
     }
     return $amounts;
   }
 
 
   /**
    * Gets a brief hint to display about non-subscriber prices.
    *
    * @return string
    *   A hint about the price
    */
   public function getPriceHint() {
     $prices = $this->getPrices();
     $nosub = $prices['%none%'];
     $rval = NULL;
     foreach ($nosub as $currency => $price) {
       if (NULL === $rval)
       {
         $rval = "$price $currency";
       }
       else
       {
         $rval = "$price $currency, " . $rval;
       }
     }
     return $rval ?? $this->t(/* Need to buy a subscription */ 'Not sold individually');
   }
 
   /**
    * Gets a brief hint to display about applicable subscriptions.
    *
    * @return string
    *   A hint about subscriptions
    */
   public function getSubscriptionHint() {
     $prices = $this->getPrices();
     $rval = NULL;
     foreach ($prices as $subscription => $details) {
       if ('%none%' === $subscription)
         continue;
       if (NULL === $rval)
       {
         $rval = $subscription;
       }
       else
       {
         $rval = $subscription . ", " . $rval;
       }
     }
     return $rval ?? $this->t(/* No subscriptions */ 'None');
   }
 
   /**
    * Gets all prices.
    *
    * @return array
    *   The prices array.
    */
   public function getPrices() {
     return $this->prices ?: [];
   }
 
   /**
    * Return the different subscriptions that this price category
    * has for which the resulting payment amount is zero (thus,
    * exlude subscriptions that would merely yield a discount).
    *
    * @return array
    *   The names (slugs) of the subscriptions
    *   that for this price category would yield a price of zero;
    *   note that empty prices do NOT count as zero but infinity!
    */
   public function getFullSubscriptions(): array {
     $subscriptions = [];
     foreach ($this->getPrices() as $tokenFamilySlug => $currencyMap) {
       foreach ($currencyMap as $currencyCode => $price) {
         if ( (is_numeric ($price)) &&
              (0.0 == (float) $price) ) {
           $subscriptions[] = $tokenFamilySlug;
           break;
         }
       }
     }
     return $subscriptions;
   }
 
   /**
    * Return the different payment choices in a way suitable
    * for GNU Taler v1 contracts.
    *
    * @param array $expirations
    *   Times when each possible subscription type expires.
    * @return array
    *    Structure suitable for the choices array in the v1 contract
    */
   public function getPaymentChoices(array $subscriptions): array {
     $max_cache = time() + 3600;
     $choices = [];
 
     foreach ($this->getPrices() as $tokenFamilySlug => $currencyMap) {
       if ("%none%" !== $tokenFamilySlug) {
         $subscription = $subscriptions[$tokenFamilySlug] ?? NULL;
         if (NULL === $subscription) {
           // Slug not known to the backend right now (backend
           // unreachable, slug renamed, or token family deleted).
           // Skip rather than emitting a warning and treating it as
           // expired.
           \Drupal::logger('taler_turnstile')->info('Subscription category @slug not advertised by backend, skipping it.', ['@slug' => $tokenFamilySlug]);
           continue;
         }
         $expi = $subscription['valid_before_s'] ?? 0;
         if ($expi < time()) {
             \Drupal::logger('taler_turnstile')->info('Subscription category @slug expired at @expire, skipping it.', ['@slug' => $tokenFamilySlug, '@expire' => $expi]);
             continue; // already expired
         }
         $max_cache = min ($max_cache,
                           $expi);
       }
       foreach ($currencyMap as $currencyCode => $price) {
         $inputs = [];
         // All amounts go through Amount::fromNumeric / Amount::add to
         // avoid float-precision artefacts (0.1 + 0.2 = 0.30000…04)
         // and to canonicalize the wire form across all three branches.
         $pay_amount = Amount::fromNumeric($currencyCode, (string) $price);
         if ("%none%" !== $tokenFamilySlug)
         {
           $inputs[] = [
             'type' => 'token',
             'token_family_slug' => $tokenFamilySlug,
             'count' => 1,
           ];
           $description = $this->t('Pay in @currency with subscription', [
             '@currency' => $currencyCode,
           ], [
             'langcode' => 'en', // force English version here!
           ]);
           $description_i18n = $this->buildTranslationMap (
             'Pay in @currency with subscription',
             ['@currency' => $currencyCode]
           );
           $choices[] = [
             'amount' => (string) $pay_amount,
             'description' => 'Pay in ' . $currencyCode . ' with subscription',
             'description_i18n' => $description_i18n,
             'inputs' => $inputs,
           ];
           $subscription_price = $this->getSubscriptionPrice ($tokenFamilySlug, $currencyCode);
           if ($subscription_price !== NULL) {
             // This subscription can be bought: charge the article
             // price plus the subscription's purchase price, computed
             // as a discrete integer addition.
             $buy_amount = $pay_amount->add(
               Amount::fromNumeric($currencyCode, (string) $subscription_price));
             $outputs = [];
             $outputs[] = [
               'type' => 'token',
               'token_family_slug' => $tokenFamilySlug,
               'count' => 1,
             ];
             $description = $this->t('Buy subscription in @currency', [
               '@currency' => $currencyCode,
             ]);
             $description_i18n = $this->buildTranslationMap (
               'Buy subscription in @currency',
               ['@currency' => $currencyCode]
             );
             $choices[] = [
               'amount' => (string) $buy_amount,
               'description' => $description,
               'description_i18n' => $description_i18n,
               'outputs' => $outputs,
             ];
           }
         }
         else // case for no subscription
         {
           $description = $this->t('Pay in @currency', [
             '@currency' => $currencyCode,
           ]);
           $description_i18n = $this->buildTranslationMap (
             'Pay in @currency',
             ['@currency' => $currencyCode]
           );
           $choices[] = [
             'amount' => (string) $pay_amount,
             'description' => $description,
             'description_i18n' => $description_i18n,
             'inputs' => $inputs,
           ];
         }
       } // for each possible currency
     } // for each type of subscription
 
     return $choices;
   }
 
   /**
    * Sets the prices array.
    *
    * @param array $prices
    *   The prices array.
    *
    * @return $this
    */
   public function setPrices(array $prices) {
     $this->prices = $prices;
     return $this;
   }
 
   /**
    * Determine the price of the given type of subscription
    * in the given currency.
    *
    * @param string $tokenFamilySlug
    *   The slug of the token family
    * @param string $currencyCode
    *   Currency code in which a price quote is desired
    *
    * @return string|null
    *   The subscription price (will map to a float), NULL on error
    */
   private function getSubscriptionPrice (string $tokenFamilySlug, string $currencyCode) {
     $config = \Drupal::config('taler_turnstile.settings');
     $subscriptions_prices = $config->get('subscription_prices') ?? [];
     $subscription_prices = $subscriptions_prices[$tokenFamilySlug] ?? [];
     $subscription_price = $subscription_prices[$currencyCode] ?? NULL;
     return $subscription_price;
   }
 
 
   /**
    * {@inheritdoc}
    *
    * Mirror this category as a "paivana"-style template in the
    * merchant backend on every save (create or update).
    */
   public function postSave(EntityStorageInterface $storage, $update = TRUE) {
     parent::postSave($storage, $update);
     /** @var \Drupal\taler_turnstile\TalerMerchantApiService $api */
     $api = \Drupal::service('taler_turnstile.api_service');
     $this->lastSyncResult = $api->syncTemplate($this);
   }
 
 
   /**
    * {@inheritdoc}
    *
    * Remove the matching template from the merchant backend when
    * this category goes away.
    */
   public static function postDelete(EntityStorageInterface $storage, array $entities) {
     parent::postDelete($storage, $entities);
     /** @var \Drupal\taler_turnstile\TalerMerchantApiService $api */
     $api = \Drupal::service('taler_turnstile.api_service');
     foreach ($entities as $entity) {
       /** @var TurnstilePriceCategory $entity */
       $entity->lastSyncResult = $api->deleteTemplate($entity->getTemplateId());
     }
   }
 
 
   /**
    * Build a translation map for all enabled languages.
    *
    * @param string $string
    *   The translatable string.
    * @param array $args
    *   Placeholder replacements.
    *
    * @return array
    *   Map of language codes to translated strings.
    */
   private function buildTranslationMap(string $string, array $args = []): array {
     $translations = [];
     $language_manager = \Drupal::languageManager();
 
     foreach ($language_manager->getLanguages() as $langcode => $language) {
       $translation = $this->t($string, $args, [
         'langcode' => $langcode,
       ]);
       $translations[$langcode] = (string) $translation;
     }
     return $translations;
   }
 
 }