@unchainedshop/plugins 3.0.0-rc.13 → 3.0.0-rc.15

package/src/payment/payrexx/handler-fastify.ts

@@ -0,0 +1,105 @@
+import { Context } from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:core-payment:payrexx:handler');
+
+export const payrexxHandler: RouteHandlerMethod = async (
+  request: FastifyRequest & {
+    unchainedContext: Context;
+  },
+  reply,
+) => {
+  const resolvedContext = request.unchainedContext as Context;
+  const { modules, services } = resolvedContext;
+
+  const { transaction } = request.body as Record<string, any>;
+
+  if (!transaction) {
+    logger.info(`unhandled event type`, {
+      type: Object.keys(request.body).join(','),
+    });
+    reply.status(200);
+    return reply.send(
+      JSON.stringify({
+        ignored: true,
+        message: `Unhandled event type: ${Object.keys(request.body).join(',')}. Supported type: transaction`,
+      }),
+    );
+  }
+  if (transaction.referenceId === '__IGNORE_WEBHOOK__' || transaction.status === 'waiting') {
+    // Ignore confirmed transactions, because those hooks are generated through calling the confirm()
+    // method in the payment adapter and could lead to double bookings.
+    logger.info(`unhandled transaction state: ${transaction.status}`);
+    reply.status(200);
+    return reply.send(
+      JSON.stringify({
+        ignored: true,
+        message: `Unhandled transaction state: ${transaction.status}`,
+      }),
+    );
+  }
+
+  logger.info(`Processing event`, {
+    transactionId: transaction.id,
+  });
+  try {
+    if (transaction.preAuthorizationId) {
+      // Pre-Authorization Flow, referenceId is a userId
+      const { referenceId: paymentProviderId, invoice } = transaction;
+      const userId = '';
+      logger.info(`register credentials for: ${userId}`);
+      await services.orders.registerPaymentCredentials(paymentProviderId, {
+        userId,
+        transactionContext: { gatewayId: invoice.paymentRequestId },
+      });
+      logger.info(`registration successful`, {
+        paymentProviderId,
+        userId,
+      });
+      reply.status(200);
+      return reply.send(
+        JSON.stringify({
+          message: 'registration successful',
+          paymentProviderId,
+          userId,
+        }),
+      );
+    } else {
+      const { referenceId: orderPaymentId, invoice } = transaction;
+      logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
+      await modules.orders.payments.logEvent(orderPaymentId, {
+        transactionId: transaction.id,
+      });
+      const orderPayment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId,
+      });
+      if (!orderPayment) {
+        throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
+      }
+
+      const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+        paymentContext: {
+          gatewayId: invoice.paymentRequestId,
+        },
+      });
+      logger.info(`checkout successful`, {
+        orderPaymentId,
+        orderId: order._id,
+      });
+      reply.status(200);
+      return reply.send(
+        JSON.stringify({
+          message: 'checkout successful',
+          orderId: order._id,
+        }),
+      );
+    }
+  } catch (error) {
+    logger.error(error, {
+      transactionId: transaction.id,
+    });
+    reply.status(500);
+    return reply.send(error.message);
+  }
+};

package/src/payment/payrexx/index.ts

@@ -9,8 +9,6 @@ import {
   PaymentError,
 } from '@unchainedshop/core';
 
-export * from './middleware.js';
-
 const logger = createLogger('unchained:core-payment:payrexx');
 
 const Payrexx: IPaymentAdapter = {

package/src/payment/postfinance-checkout/handler-fastify.ts

@@ -0,0 +1,52 @@
+import { Context } from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import { WebhookData } from './types.js';
+import { getTransaction, getTransactionCompletion } from './api.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:core-payment:postfinance-checkout');
+
+export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & {
+    unchainedContext: Context;
+  },
+  reply,
+) => {
+  const context = req.unchainedContext as Context;
+  const { services, modules } = context;
+  const data = req.body as WebhookData;
+  if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
+    try {
+      const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
+      const transaction = await getTransaction(
+        transactionCompletion.linkedTransaction as unknown as string,
+      );
+      const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
+      const orderPayment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId,
+      });
+      if (!orderPayment) throw new Error('Order Payment not found');
+
+      const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+        paymentContext: {
+          transactionId: transactionCompletion.linkedTransaction,
+        },
+      });
+      logger.info(
+        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+      );
+      reply.status(200);
+      return reply.send(`Order marked as paid: ${order.orderNumber}`);
+    } catch (e) {
+      logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
+      reply.status(500);
+      return reply.send({ name: e.name, code: e.code, message: e.message });
+    }
+  } else {
+    logger.error(
+      `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
+    );
+    reply.status(404);
+    return reply.send();
+  }
+};

package/src/payment/postfinance-checkout/index.ts

@@ -24,8 +24,6 @@ import {
 import { orderIsPaid } from './utils.js';
 import { CompletionModes, IntegrationModes, SignResponse } from './types.js';
 
-export * from './middleware.js';
-
 const { PostFinanceCheckout } = pf;
 
 const {

package/src/payment/saferpay/adapter.ts

@@ -1,7 +1,7 @@
 import { mongodb } from '@unchainedshop/mongodb';
 import { PaymentPageInitializeInput, SaferpayClient } from './api/index.js';
 import { buildSignature } from './buildSignature.js';
-import { SaferpayTransactionsModule } from './module/configureSaferpayTransactionsModule.js';
+import { SaferpayTransactionsModule } from './module.js';
 import {
   OrderPricingSheet,
   IPaymentAdapter,
@@ -10,8 +10,6 @@ import {
   PaymentError,
 } from '@unchainedshop/core';
 
-export * from './middleware.js';
-
 const {
   SAFERPAY_BASE_URL = 'https://test.saferpay.com/api',
   SAFERPAY_CUSTOMER_ID,
@@ -48,7 +46,7 @@ export const WordlineSaferpay: IPaymentAdapter = {
 
   actions: (config, context) => {
     const { modules } = context as typeof context & {
-      modules: { saferpayTransactions: SaferpayTransactionsModule };
+      modules: SaferpayTransactionsModule;
     };
 
     const createSaferPayClient = () => {

package/src/payment/saferpay/{middleware.ts → handler-express.ts}

@@ -1,13 +1,13 @@
 import { Context } from '@unchainedshop/api';
 import { createLogger } from '@unchainedshop/logger';
 import { buildSignature } from './buildSignature.js';
-import { SaferpayTransactionsModule } from './module/configureSaferpayTransactionsModule.js';
+import { SaferpayTransactionsModule } from './module.js';
 
-const logger = createLogger('unchained:core-payment:saferpay:webhook');
+const logger = createLogger('unchained:core-payment:saferpay:handler');
 
 export const saferpayHandler = async (request, response) => {
   const resolvedContext = request.unchainedContext as Context & {
-    modules: { saferpayTransactions: SaferpayTransactionsModule };
+    modules: SaferpayTransactionsModule;
   };
   const { modules, services } = resolvedContext;
 

package/src/payment/saferpay/handler-fastify.ts

@@ -0,0 +1,75 @@
+import { Context } from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import { buildSignature } from './buildSignature.js';
+import { SaferpayTransactionsModule } from './module.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:core-payment:saferpay:handler');
+
+export const saferpayHandler: RouteHandlerMethod = async (
+  request: FastifyRequest & {
+    unchainedContext: Context;
+  },
+  reply,
+) => {
+  const resolvedContext = request.unchainedContext as Context & {
+    modules: SaferpayTransactionsModule;
+  };
+  const { modules, services } = resolvedContext;
+
+  const { orderPaymentId, signature, transactionId } = request.query as Record<string, string>;
+  const isValidRequest =
+    typeof orderPaymentId === 'string' &&
+    typeof signature === 'string' &&
+    typeof transactionId === 'string' &&
+    orderPaymentId &&
+    transactionId &&
+    signature;
+
+  if (!isValidRequest) {
+    logger.warn(`orderPaymentId missing in query`);
+    reply.status(404);
+    return reply.send();
+  }
+
+  try {
+    logger.info(`checkout with orderPaymentId: ${orderPaymentId}`);
+    const orderPayment = await modules.orders.payments.findOrderPayment({
+      orderPaymentId,
+    });
+    if (!orderPayment) {
+      throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
+    }
+
+    const correctSignature = await buildSignature(transactionId, orderPaymentId);
+
+    if (correctSignature !== signature) {
+      throw new Error('Invalid signature');
+    }
+
+    const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+      paymentContext: {
+        transactionId,
+      },
+    });
+    logger.info(`checkout successful`, {
+      orderPaymentId,
+      orderId: order._id,
+    });
+    reply.status(200);
+    return reply.send(
+      JSON.stringify({
+        message: 'checkout successful',
+        orderPaymentId,
+        orderId: order._id,
+      }),
+    );
+  } catch (error) {
+    logger.error(error, {
+      orderPaymentId,
+      transactionId,
+    });
+    reply.status(500);
+    return reply.send(error.message);
+  }
+};

package/src/payment/saferpay/index.ts

@@ -1,3 +1,6 @@
 export * from './adapter.js';
-export * from './module/configureSaferpayTransactionsModule.js';
-export * from './middleware.js';
+
+import saferpayTransactionsModule, { type SaferpayTransactionsModule } from './module.js';
+
+export type { SaferpayTransactionsModule };
+export default saferpayTransactionsModule;

package/src/payment/saferpay/{module/configureSaferpayTransactionsModule.ts → module.ts}

@@ -1,7 +1,7 @@
 import { mongodb } from '@unchainedshop/mongodb';
-import { SaferpayTransactionsCollection } from '../db/SaferpayTransactionsCollection.js';
+import { SaferpayTransactionsCollection } from './db/SaferpayTransactionsCollection.js';
 
-export const configureSaferpayTransactionsModule = async ({ db }: { db: mongodb.Db }) => {
+const configureSaferpayTransactionsModule = async ({ db }: { db: mongodb.Db }) => {
   const SaferpayTransactions = await SaferpayTransactionsCollection(db);
 
   return {
@@ -30,4 +30,12 @@ export const configureSaferpayTransactionsModule = async ({ db }: { db: mongodb.
   };
 };
 
-export type SaferpayTransactionsModule = Awaited<ReturnType<typeof configureSaferpayTransactionsModule>>;
+export default {
+  saferpayTransactions: {
+    configure: configureSaferpayTransactionsModule,
+  },
+};
+
+export type SaferpayTransactionsModule = {
+  saferpayTransactions: Awaited<ReturnType<typeof configureSaferpayTransactionsModule>>;
+};

package/src/payment/stripe/{middleware.ts → handler-express.ts}

@@ -2,7 +2,7 @@ import { Context } from '@unchainedshop/api';
 import { createLogger } from '@unchainedshop/logger';
 import stripeClient from './stripe.js';
 
-const logger = createLogger('unchained:core-payment:stripe:webhook');
+const logger = createLogger('unchained:core-payment:stripe:handler');
 
 export const WebhookEventTypes = {
   PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',

package/src/payment/stripe/handler-fastify.ts

@@ -0,0 +1,139 @@
+import { Context } from '@unchainedshop/api';
+import { createLogger } from '@unchainedshop/logger';
+import stripeClient from './stripe.js';
+import { FastifyRequest, RouteHandlerMethod } from 'fastify';
+
+const logger = createLogger('unchained:core-payment:stripe:handler');
+
+export const WebhookEventTypes = {
+  PAYMENT_INTENT_SUCCEEDED: 'payment_intent.succeeded',
+  SETUP_INTENT_SUCCEEDED: 'setup_intent.succeeded',
+};
+
+export const stripeHandler: RouteHandlerMethod = async (
+  req: FastifyRequest & {
+    unchainedContext: Context;
+  },
+  reply,
+) => {
+  const resolvedContext = req.unchainedContext as Context;
+  const { modules, services } = resolvedContext;
+
+  let event;
+
+  try {
+    const stripe = stripeClient();
+    const sig = req.headers['stripe-signature'];
+    event = stripe.webhooks.constructEvent(req.body as string, sig, process.env.STRIPE_ENDPOINT_SECRET);
+  } catch (err) {
+    logger.error(`Error constructing event: ${err.message}`);
+    reply.status(400);
+    return reply.send(err.message);
+  }
+
+  if (!Object.values(WebhookEventTypes).includes(event.type)) {
+    logger.info(`unhandled event type`, {
+      type: event.type,
+    });
+    reply.status(200);
+    return reply.send(
+      JSON.stringify({
+        ignored: true,
+        message: `Unhandled event type: ${event.type}. Supported types: ${Object.values(WebhookEventTypes).join(', ')}`,
+      }),
+    );
+  }
+
+  const environmentInMetadata = event.data?.object?.metadata?.environment || '';
+  const environmentInEnv = process.env.STRIPE_WEBHOOK_ENVIRONMENT || '';
+  if (environmentInMetadata !== environmentInEnv) {
+    logger.info(`unhandled event environment`, {
+      type: event.type,
+      environment: environmentInMetadata,
+    });
+    reply.status(200);
+    return reply.send(
+      JSON.stringify({
+        ignored: true,
+        message: `Unhandled event environment: ${environmentInMetadata}. Supported environment: ${environmentInEnv}`,
+      }),
+    );
+  }
+
+  logger.info(`Processing event`, {
+    type: event.type,
+  });
+  try {
+    if (event.type === WebhookEventTypes.PAYMENT_INTENT_SUCCEEDED) {
+      const paymentIntent = event.data.object;
+      const { orderPaymentId } = paymentIntent.metadata || {};
+
+      logger.info(`checkout with orderPaymentId: ${orderPaymentId}`, {
+        type: event.type,
+      });
+
+      await modules.orders.payments.logEvent(orderPaymentId, event);
+      const orderPayment = await modules.orders.payments.findOrderPayment({
+        orderPaymentId,
+      });
+
+      if (!orderPayment) {
+        throw new Error(`order payment not found with orderPaymentId: ${orderPaymentId}`);
+      }
+
+      const order = await services.orders.checkoutOrder(orderPayment.orderId, {
+        paymentContext: {
+          paymentIntentId: paymentIntent.id,
+        },
+      });
+
+      logger.info(`checkout successful`, {
+        orderPaymentId,
+        orderId: order._id,
+        type: event.type,
+      });
+      reply.status(200);
+      return reply.send(
+        JSON.stringify({
+          message: 'checkout successful',
+          orderId: order._id,
+        }),
+      );
+    } else if (event.type === WebhookEventTypes.SETUP_INTENT_SUCCEEDED) {
+      const setupIntent = event.data.object;
+      const { paymentProviderId, userId } = setupIntent.metadata || {};
+
+      logger.info(`registered payment credential with paymentProviderId: ${paymentProviderId}`, {
+        type: event.type,
+        userId,
+      });
+
+      const paymentCredentials = await services.orders.registerPaymentCredentials(paymentProviderId, {
+        transactionContext: {
+          setupIntentId: setupIntent.id,
+        },
+        userId,
+      });
+
+      logger.info(`payment credentials registration successful`, {
+        userId,
+        paymentProviderId,
+        paymentCredentialsId: paymentCredentials?._id,
+        type: event.type,
+      });
+      reply.status(200);
+      return reply.send(
+        JSON.stringify({
+          message: 'payment credentials registration successful',
+          paymentCredentialsId: paymentCredentials?._id,
+        }),
+      );
+    }
+  } catch (error) {
+    logger.error(error, {
+      type: event.type,
+    });
+    reply.status(500);
+    return reply.send(error.message);
+  }
+};

package/src/payment/stripe/index.ts

@@ -8,8 +8,6 @@ import {
   PaymentError,
 } from '@unchainedshop/core';
 
-export * from './middleware.js';
-
 const logger = createLogger('unchained:core-payment:stripe');
 
 const Stripe: IPaymentAdapter = {

package/src/presets/all-express.ts

@@ -0,0 +1,51 @@
+import express from 'express';
+import { UnchainedCore } from '@unchainedshop/core';
+
+import connectCryptoToExpress from './crypto-express.js';
+import connectBaseToExpress from './base-express.js';
+
+import { datatransHandler } from '../payment/datatrans-v2/handler-express.js';
+import { stripeHandler } from '../payment/stripe/handler-express.js';
+import { postfinanceCheckoutHandler } from '../payment/postfinance-checkout/handler-express.js';
+import { appleIAPHandler } from '../payment/apple-iap/handler-express.js';
+import { payrexxHandler } from '../payment/payrexx/handler-express.js';
+import { saferpayHandler } from '../payment/saferpay/handler-express.js';
+import { configureGenerateOrderAutoscheduling } from '../worker/enrollment-order-generator.js';
+
+const {
+  STRIPE_WEBHOOK_PATH = '/payment/stripe',
+  PAYREXX_WEBHOOK_PATH = '/payment/payrexx',
+  PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout',
+  DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook',
+  APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap',
+  SAFERPAY_WEBHOOK_PATH = '/payment/saferpay/webhook',
+} = process.env;
+
+export default (app: express.Express, { unchainedAPI }: { unchainedAPI: UnchainedCore }) => {
+  connectBaseToExpress(app);
+  connectCryptoToExpress(app, unchainedAPI);
+
+  app.use(STRIPE_WEBHOOK_PATH, express.raw({ type: 'application/json' }), stripeHandler);
+  app.use(PFCHECKOUT_WEBHOOK_PATH, express.json(), postfinanceCheckoutHandler);
+
+  app.use(
+    DATATRANS_WEBHOOK_PATH,
+    express.text({
+      type: 'application/json',
+    }),
+    datatransHandler,
+  );
+
+  app.use(
+    APPLE_IAP_WEBHOOK_PATH,
+    express.json({
+      strict: false,
+    }),
+    appleIAPHandler,
+  );
+
+  app.use(PAYREXX_WEBHOOK_PATH, express.json({ type: 'application/json' }), payrexxHandler);
+  app.use(SAFERPAY_WEBHOOK_PATH, saferpayHandler);
+
+  configureGenerateOrderAutoscheduling();
+};

package/src/presets/all-fastify.ts

@@ -0,0 +1,87 @@
+import { UnchainedCore } from '@unchainedshop/core';
+import { FastifyInstance } from 'fastify';
+
+import connectCryptoToFastify from './crypto-fastify.js';
+import connectBaseToFastify from './base-fastify.js';
+
+import { stripeHandler } from '../payment/stripe/handler-fastify.js';
+import { postfinanceCheckoutHandler } from '../payment/postfinance-checkout/handler-fastify.js';
+import { datatransHandler } from '../payment/datatrans-v2/handler-fastify.js';
+import { appleIAPHandler } from '../payment/apple-iap/handler-fastify.js';
+import { payrexxHandler } from '../payment/payrexx/handler-fastify.js';
+import { saferpayHandler } from '../payment/saferpay/handler-fastify.js';
+import { configureGenerateOrderAutoscheduling } from '../worker/enrollment-order-generator.js';
+
+const {
+  STRIPE_WEBHOOK_PATH = '/payment/stripe',
+  PAYREXX_WEBHOOK_PATH = '/payment/payrexx',
+  PFCHECKOUT_WEBHOOK_PATH = '/payment/postfinance-checkout',
+  DATATRANS_WEBHOOK_PATH = '/payment/datatrans/webhook',
+  APPLE_IAP_WEBHOOK_PATH = '/payment/apple-iap',
+  SAFERPAY_WEBHOOK_PATH = '/payment/saferpay/webhook',
+} = process.env;
+
+export default (fastify: FastifyInstance, { unchainedAPI }: { unchainedAPI: UnchainedCore }) => {
+  connectBaseToFastify(fastify);
+  connectCryptoToFastify(fastify, unchainedAPI);
+
+  fastify.register((s, opts, registered) => {
+    // Disable JSON parsing!
+    // fastify.addContentTypeParser(
+    //   'application/json',
+    //   { parseAs: 'string', bodyLimit: 1024 * 1024 },
+    //   function (req, body, done) {
+    //     try {
+    //       done(null, body);
+    //     } catch (err) {
+    //       err.statusCode = 400;
+    //       done(err, undefined);
+    //     }
+    //   },
+    // );
+    s.addContentTypeParser(
+      'application/json',
+      { parseAs: 'string', bodyLimit: 1024 * 1024 },
+      s.defaultTextParser,
+    );
+    s.route({
+      url: STRIPE_WEBHOOK_PATH,
+      method: 'POST',
+      handler: stripeHandler,
+    });
+    s.route({
+      url: DATATRANS_WEBHOOK_PATH,
+      method: 'POST',
+      handler: datatransHandler,
+    });
+    registered();
+  });
+
+  fastify.route({
+    url: PFCHECKOUT_WEBHOOK_PATH,
+    method: 'POST',
+    handler: postfinanceCheckoutHandler,
+  });
+
+  fastify.route({
+    url: APPLE_IAP_WEBHOOK_PATH,
+    method: 'POST',
+    handler: appleIAPHandler,
+  });
+
+  fastify.route({
+    url: PAYREXX_WEBHOOK_PATH,
+    method: 'POST',
+    handler: payrexxHandler,
+  });
+
+  fastify.route({
+    url: SAFERPAY_WEBHOOK_PATH,
+    method: 'GET',
+    handler: saferpayHandler,
+  });
+
+  // app.use(STRIPE_WEBHOOK_PATH, express.raw({ type: 'application/json' }), stripeHandler);
+
+  configureGenerateOrderAutoscheduling();
+};

package/src/presets/all.ts

@@ -0,0 +1,35 @@
+import baseModules from './base.js';
+import './countries/ch.js';
+import cryptoModules from './crypto.js';
+
+// Delivery
+import '../delivery/send-message.js';
+import '../delivery/stores.js';
+
+// Payment
+import '../payment/invoice-prepaid.js';
+import '../payment/paypal-checkout.js';
+import appleTransactionsModules from '../payment/apple-iap/index.js';
+import saferpayTransactionsModules from '../payment/saferpay/index.js';
+import '../payment/stripe/index.js';
+import '../payment/postfinance-checkout/index.js';
+import '../payment/datatrans-v2/index.js';
+import '../payment/payrexx/index.js';
+
+// Filter & Search
+import '../filters/strict-equal.js';
+import '../filters/local-search.js';
+
+// Workers
+import '../worker/sms.js';
+import '../worker/push-notification.js';
+import '../worker/enrollment-order-generator.js';
+
+const modules = {
+  ...baseModules,
+  ...cryptoModules,
+  ...appleTransactionsModules,
+  ...saferpayTransactionsModules,
+};
+
+export default modules;

package/src/presets/base-express.ts

@@ -1,7 +1,7 @@
-import { gridfsHandler } from '../files/gridfs/gridfs-webhook.js';
+import handler from '../files/gridfs/handler-express.js';
 
 const { GRIDFS_PUT_SERVER_PATH = '/gridfs' } = process.env;
 
 export default (app) => {
-  app.use(GRIDFS_PUT_SERVER_PATH, gridfsHandler);
+  app.use(GRIDFS_PUT_SERVER_PATH, handler);
 };