@unchainedshop/core-orders 2.13.0 → 3.0.0-alpha2

package/src/module/configureOrderDiscountsModule.ts

@@ -1,8 +1,6 @@
 import { ModuleMutations, UnchainedCore } from '@unchainedshop/types/core.js';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
 import { OrderDiscount, OrderDiscountsModule } from '@unchainedshop/types/orders.discounts.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
 import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
 import { OrderDiscountsSchema } from '../db/OrderDiscountsSchema.js';
 import { OrderDiscountTrigger } from '../db/OrderDiscountTrigger.js';
@@ -25,10 +23,8 @@ export const buildFindByIdSelector = (orderDiscountId: string) =>
 
 export const configureOrderDiscountsModule = ({
   OrderDiscounts,
-  updateCalculation,
 }: {
   OrderDiscounts: mongodb.Collection<OrderDiscount>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderDiscountsModule => {
   registerEvents(ORDER_DISCOUNT_EVENTS);
 
@@ -51,11 +47,6 @@ export const configureOrderDiscountsModule = ({
 
   const createDiscount: OrderDiscountsModule['create'] = async (doc) => {
     const normalizedTrigger = doc.trigger || OrderDiscountTrigger.USER;
-
-    log(`Create Order Discount: ${doc.discountKey} with trigger ${normalizedTrigger}`, {
-      orderId: doc.orderId,
-    });
-
     const discountId = await mutations.create({ ...doc, trigger: normalizedTrigger });
     const discount = await OrderDiscounts.findOne(buildFindByIdSelector(discountId));
     return discount;
@@ -64,22 +55,13 @@ export const configureOrderDiscountsModule = ({
   const deleteDiscount: OrderDiscountsModule['delete'] = async (orderDiscountId, unchainedAPI) => {
     const selector = buildFindByIdSelector(orderDiscountId);
     const discount = await OrderDiscounts.findOne(selector, {});
-
-    log(`OrderDiscounts -> Remove Discount ${orderDiscountId}`, {
-      orderId: discount.orderId,
-    });
-
     if (discount.trigger === OrderDiscountTrigger.USER) {
       // Release
       const adapter = await getAdapter(discount, unchainedAPI);
       if (!adapter) return null;
       await adapter.release();
-
-      await OrderDiscounts.deleteOne(selector);
-      await updateCalculation(discount.orderId, unchainedAPI);
-    } else {
-      await OrderDiscounts.deleteOne(selector);
     }
+    await OrderDiscounts.deleteOne(selector);
     await emit('ORDER_REMOVE_DISCOUNT', { discount });
     return discount;
   };
@@ -110,15 +92,10 @@ export const configureOrderDiscountsModule = ({
     { code, orderId }: { code: string; orderId: string },
     unchainedAPI: UnchainedCore,
   ) => {
-    log(`OrderDiscounts -> Try to grab ${code}`, { orderId });
-
     const existingDiscount = await OrderDiscounts.findOne({ code, orderId });
-
     if (existingDiscount) throw new Error(OrderDiscountErrorCode.CODE_ALREADY_PRESENT);
-
     const discount = await OrderDiscounts.findOne({ code, orderId: null });
     if (!discount) return null;
-
     const discountId = discount._id;
     try {
       const updatedDiscount = await updateDiscount(discountId, { orderId });
@@ -199,7 +176,6 @@ export const configureOrderDiscountsModule = ({
 
         try {
           const reservedDiscount = await reserveDiscount(newDiscount, unchainedAPI);
-          await updateCalculation(order._id, unchainedAPI);
           await emit('ORDER_ADD_DISCOUNT', { discount: reserveDiscount });
           return reservedDiscount;
         } catch (error) {

package/src/module/configureOrderPaymentsModule.ts

@@ -1,12 +1,10 @@
 import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
 import {
   OrderPayment,
   OrderPaymentsModule,
   OrderPaymentStatus,
 } from '@unchainedshop/types/orders.payments.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
 import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
 import { OrderPaymentsSchema } from '../db/OrderPaymentsSchema.js';
 
@@ -35,10 +33,8 @@ export const buildFindByContextDataSelector = (context: any): mongodb.Filter<Ord
 
 export const configureOrderPaymentsModule = ({
   OrderPayments,
-  updateCalculation,
 }: {
   OrderPayments: mongodb.Collection<OrderPayment>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderPaymentsModule => {
   registerEvents(ORDER_PAYMENT_EVENTS);
 
@@ -70,8 +66,6 @@ export const configureOrderPaymentsModule = ({
     orderPaymentId,
     { status, transactionId, info },
   ) => {
-    log(`OrderPayment ${orderPaymentId} -> New Status: ${status}`);
-
     const date = new Date();
     const modifier: mongodb.UpdateFilter<OrderPayment> = {
       $set: { status, updated: new Date() },
@@ -293,13 +287,10 @@ export const configureOrderPaymentsModule = ({
       await emit('ORDER_PAY', { orderPayment });
     },
 
-    updateContext: async (orderPaymentId, context, unchainedAPI) => {
+    updateContext: async (orderPaymentId, context) => {
       const selector = buildFindByIdSelector(orderPaymentId);
       if (!context || Object.keys(context).length === 0) return OrderPayments.findOne(selector, {});
 
-      log(`OrderPayment ${orderPaymentId} -> Update Context`, {
-        context,
-      });
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
@@ -315,7 +306,6 @@ export const configureOrderPaymentsModule = ({
       );
 
       if (result.ok) {
-        await updateCalculation(result.value.orderId, unchainedAPI);
         await emit('ORDER_UPDATE_PAYMENT', {
           orderPayment: result.value,
         });
@@ -328,10 +318,6 @@ export const configureOrderPaymentsModule = ({
     updateStatus,
 
     updateCalculation: async (orderPayment, unchainedAPI) => {
-      log(`OrderPayment ${orderPayment._id} -> Update Calculation`, {
-        orderId: orderPayment.orderId,
-      });
-
       const calculation = await unchainedAPI.modules.payment.paymentProviders.calculate(
         {
           item: orderPayment,

package/src/module/configureOrderPositionsModule.ts

@@ -1,15 +1,6 @@
-import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { OrdersModule } from '@unchainedshop/types/orders.js';
 import { OrderPosition, OrderPositionsModule } from '@unchainedshop/types/orders.positions.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
-import {
-  generateDbFilterById,
-  generateDbMutations,
-  generateDbObjectId,
-  mongodb,
-} from '@unchainedshop/mongodb';
-import { OrderPositionsSchema } from '../db/OrderPositionsSchema.js';
+import { generateDbFilterById, generateDbObjectId, mongodb } from '@unchainedshop/mongodb';
 import { ordersSettings } from '../orders-settings.js';
 
 const ORDER_POSITION_EVENTS: string[] = [
@@ -27,18 +18,11 @@ export const buildFindByIdSelector = (orderPositionId: string, orderId?: string)
 
 export const configureOrderPositionsModule = ({
   OrderPositions,
-  updateCalculation,
 }: {
   OrderPositions: mongodb.Collection<OrderPosition>;
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderPositionsModule => {
   registerEvents(ORDER_POSITION_EVENTS);
 
-  const mutations = generateDbMutations<OrderPosition>(OrderPositions, OrderPositionsSchema, {
-    permanentlyDeleteByDefault: true,
-    hasCreateOnly: false,
-  }) as ModuleMutations<OrderPosition>;
-
   return {
     // Queries
     findOrderPosition: async ({ itemId }, options) => {
@@ -72,68 +56,18 @@ export const configureOrderPositionsModule = ({
       });
     },
 
-    // Mutations
-
-    create: async (
-      { configuration, context, quantity, quotationId },
-      { order, product, originalProduct },
-      unchainedAPI,
-    ) => {
-      const orderId = order._id;
-      const productId = product._id;
-      const originalProductId = originalProduct ? originalProduct._id : undefined;
-
-      log(
-        `Create ${quantity}x Position with Product ${productId} ${
-          quotationId ? ` (${quotationId})` : ''
-        }`,
-        { orderId, productId, originalProductId },
-      );
-
-      const positionId = await mutations.create({
-        orderId,
-        productId,
-        originalProductId,
-        quotationId,
-        quantity,
-        configuration,
-        context,
-        calculation: [],
-        scheduling: [],
-      });
-
-      await updateCalculation(orderId, unchainedAPI);
-
-      return OrderPositions.findOne(buildFindByIdSelector(positionId));
-    },
-
-    delete: async (orderPositionId, unchainedAPI) => {
+    delete: async (orderPositionId) => {
       const selector = buildFindByIdSelector(orderPositionId);
-
-      log(`Remove Position ${orderPositionId}`, {
-        orderPositionId,
-      });
-
       const orderPosition = await OrderPositions.findOneAndDelete(selector, {});
-
-      await updateCalculation(orderPosition.orderId, unchainedAPI);
-
       await emit('ORDER_REMOVE_CART_ITEM', {
         orderPosition,
       });
-
       return { ...orderPosition, calculation: [] };
     },
 
-    removePositions: async ({ orderId }, unchainedAPI) => {
-      log('Remove Positions', { orderId });
-
+    removePositions: async ({ orderId }) => {
       const result = await OrderPositions.deleteMany({ orderId });
-
-      await updateCalculation(orderId, unchainedAPI);
-
       await emit('ORDER_EMPTY_CART', { orderId, count: result.deletedCount });
-
       return result.deletedCount;
     },
 
@@ -173,11 +107,9 @@ export const configureOrderPositionsModule = ({
         unchainedAPI,
       );
 
-      await OrderPositions.updateOne(selector, modifier);
-
-      await updateCalculation(order._id, unchainedAPI);
-
-      const updatedOrderPosition = await OrderPositions.findOne(selector, {});
+      const updatedOrderPosition = await OrderPositions.findOneAndUpdate(selector, modifier, {
+        returnDocument: 'after',
+      });
 
       await emit('ORDER_UPDATE_CART_ITEM', {
         orderPosition: updatedOrderPosition,
@@ -186,9 +118,7 @@ export const configureOrderPositionsModule = ({
       return updatedOrderPosition;
     },
 
-    removeProductByIdFromAllOpenPositions: async (productId, unchainedAPI) => {
-      log('Remove Position Product', { productId });
-
+    removeProductByIdFromAllOpenPositions: async (productId) => {
       const positions = await OrderPositions.aggregate([
         {
           $match: {
@@ -211,15 +141,7 @@ export const configureOrderPositionsModule = ({
       ]).toArray();
 
       const positionIds = positions.map((o) => o._id);
-      const result = await OrderPositions.deleteMany({ _id: { $in: positionIds } });
-
-      const orderIdsToRecalculate = positions.map((o) => o.orderId);
-      await Promise.all(
-        [...new Set(orderIdsToRecalculate)].map(async (orderIdToRecalculate) => {
-          await updateCalculation(orderIdToRecalculate, unchainedAPI);
-        }),
-      );
-
+      await OrderPositions.deleteMany({ _id: { $in: positionIds } });
       await Promise.all(
         positions.map(async (orderPosition) => {
           await emit('ORDER_REMOVE_CART_ITEM', {
@@ -228,7 +150,8 @@ export const configureOrderPositionsModule = ({
         }),
       );
 
-      return result.deletedCount;
+      const orderIdsToRecalculate = positions.map((o) => o.orderId);
+      return orderIdsToRecalculate;
     },
 
     updateScheduling: async ({ order, orderDelivery, orderPosition }, unchainedAPI) => {
@@ -291,10 +214,6 @@ export const configureOrderPositionsModule = ({
     },
 
     updateCalculation: async (orderPosition, unchainedAPI) => {
-      log(`OrderPosition ${orderPosition._id} -> Update Calculation`, {
-        orderId: orderPosition.orderId,
-      });
-
       const calculation = await unchainedAPI.modules.products.calculate(
         { item: orderPosition, configuration: orderPosition.configuration },
         unchainedAPI,
@@ -364,8 +283,6 @@ export const configureOrderPositionsModule = ({
         { upsert: true },
       );
 
-      await updateCalculation(orderId, unchainedAPI);
-
       const upsertedOrderPosition = await OrderPositions.findOne(selector);
 
       await emit('ORDER_ADD_PRODUCT', { orderPosition: upsertedOrderPosition });

package/src/module/configureOrdersModule-mutations.ts

@@ -1,9 +1,8 @@
 import { ModuleMutations } from '@unchainedshop/types/core.js';
-import { Order, OrderStatus, OrderMutations, OrdersModule } from '@unchainedshop/types/orders.js';
+import { Order, OrderStatus, OrderMutations } from '@unchainedshop/types/orders.js';
 import { OrderDelivery } from '@unchainedshop/types/orders.deliveries.js';
 import { OrderPayment } from '@unchainedshop/types/orders.payments.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log, LogLevel } from '@unchainedshop/logger';
 import { generateDbFilterById, generateDbMutations, mongodb } from '@unchainedshop/mongodb';
 import { OrderPosition } from '@unchainedshop/types/orders.positions.js';
 import { OrdersSchema } from '../db/OrdersSchema.js';
@@ -21,15 +20,11 @@ export const configureOrderModuleMutations = ({
   OrderDeliveries,
   OrderPayments,
   OrderPositions,
-  initProviders,
-  updateCalculation,
 }: {
   Orders: mongodb.Collection<Order>;
   OrderDeliveries: mongodb.Collection<OrderDelivery>;
   OrderPayments: mongodb.Collection<OrderPayment>;
   OrderPositions: mongodb.Collection<OrderPosition>;
-  initProviders: OrdersModule['initProviders'];
-  updateCalculation: OrdersModule['updateCalculation'];
 }): OrderMutations => {
   registerEvents(ORDER_EVENTS);
 
@@ -65,25 +60,6 @@ export const configureOrderModuleMutations = ({
       return deletedCount;
     },
 
-    initProviders,
-
-    invalidateProviders: async (unchainedAPI, maxAgeDays = 30) => {
-      log('Orders: Start invalidating cart providers', {
-        level: LogLevel.Verbose,
-      });
-
-      const ONE_DAY_IN_MILLISECONDS = 86400000;
-
-      const minValidDate = new Date(new Date().getTime() - maxAgeDays * ONE_DAY_IN_MILLISECONDS);
-
-      const orders = await Orders.find({
-        status: { $eq: null },
-        updated: { $gte: minValidDate },
-      }).toArray();
-
-      await Promise.all(orders.map((order) => initProviders(order, unchainedAPI)));
-    },
-
     setCartOwner: async ({ orderId, userId }) => {
       await Orders.updateOne(generateDbFilterById(orderId), {
         $set: {
@@ -103,8 +79,7 @@ export const configureOrderModuleMutations = ({
       );
     },
 
-    setDeliveryProvider: async (orderId, deliveryProviderId, unchainedAPI) => {
-      const { modules } = unchainedAPI;
+    setDeliveryProvider: async (orderId, deliveryProviderId, { modules }) => {
       const delivery = await OrderDeliveries.findOne({
         orderId,
         deliveryProviderId,
@@ -121,17 +96,17 @@ export const configureOrderModuleMutations = ({
           })
         )._id;
 
-      log(`Set Delivery Provider ${deliveryProviderId}`, { orderId });
-
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          deliveryId,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            deliveryId,
+            updated: new Date(),
+          },
         },
-      });
-
-      const order = await updateCalculation(orderId, unchainedAPI);
+        { returnDocument: 'after' },
+      );
 
       await emit('ORDER_SET_DELIVERY_PROVIDER', {
         order,
@@ -159,14 +134,14 @@ export const configureOrderModuleMutations = ({
             status: null,
           })
         )._id;
-      log(`Set Payment Provider ${paymentProviderId}`, { orderId });
-
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: { paymentId, updated: new Date() },
-      });
-
-      const order = await updateCalculation(orderId, unchainedAPI);
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: { paymentId, updated: new Date() },
+        },
+        { returnDocument: 'after' },
+      );
 
       await emit('ORDER_SET_PAYMENT_PROVIDER', {
         order,
@@ -176,45 +151,46 @@ export const configureOrderModuleMutations = ({
       return order;
     },
 
-    updateBillingAddress: async (orderId, billingAddress, unchainedAPI) => {
-      log('Update Invoicing Address', { orderId });
-
+    updateBillingAddress: async (orderId, billingAddress) => {
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          billingAddress,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            billingAddress,
+            updated: new Date(),
+          },
         },
-      });
+        { returnDocument: 'after' },
+      );
 
-      const order = await updateCalculation(orderId, unchainedAPI);
       await emit('ORDER_UPDATE', { order, field: 'billing' });
       return order;
     },
 
-    updateContact: async (orderId, contact, unchainedAPI) => {
-      log('Update Contact', { orderId });
-
+    updateContact: async (orderId, contact) => {
       const selector = generateDbFilterById(orderId);
-      await Orders.updateOne(selector, {
-        $set: {
-          contact,
-          updated: new Date(),
+      const order = await Orders.findOneAndUpdate(
+        selector,
+        {
+          $set: {
+            contact,
+            updated: new Date(),
+          },
         },
-      });
+        { returnDocument: 'after' },
+      );
 
-      const order = await updateCalculation(orderId, unchainedAPI);
       await emit('ORDER_UPDATE', { order, field: 'contact' });
       return order;
     },
 
-    updateContext: async (orderId, context, unchainedAPI) => {
+    updateContext: async (orderId, context) => {
       const selector = generateDbFilterById<Order>(orderId);
       selector.status = { $in: [null, OrderStatus.PENDING] };
 
       if (!context || Object.keys(context).length === 0) return Orders.findOne(selector, {});
 
-      log('Update Arbitrary Context', { orderId, context });
       const contextSetters = Object.fromEntries(
         Object.entries(context).map(([key, value]) => [`context.${key}`, value]),
       );
@@ -226,17 +202,14 @@ export const configureOrderModuleMutations = ({
             updated: new Date(),
           },
         },
-        { includeResultMetadata: true },
+        { includeResultMetadata: true, returnDocument: 'after' },
       );
 
       if (result.ok) {
-        const calculatedOrder = await updateCalculation(orderId, unchainedAPI);
-        await emit('ORDER_UPDATE', { order: calculatedOrder, field: 'context' });
-        return calculatedOrder;
+        await emit('ORDER_UPDATE', { order: result.value, field: 'context' });
+        return result.value;
       }
       return null;
     },
-
-    updateCalculation,
   };
 };

package/src/module/configureOrdersModule-processing.ts

@@ -5,7 +5,6 @@ import { OrderDelivery } from '@unchainedshop/types/orders.deliveries.js';
 import { OrderPayment } from '@unchainedshop/types/orders.payments.js';
 import { OrderPosition } from '@unchainedshop/types/orders.positions.js';
 import { emit, registerEvents } from '@unchainedshop/events';
-import { log } from '@unchainedshop/logger';
 import { ProductType } from '@unchainedshop/types/products.js';
 import { UnchainedCore } from '@unchainedshop/types/core.js';
 import { ordersSettings } from '../orders-settings.js';
@@ -94,7 +93,6 @@ export const configureOrderModuleProcessing = ({
     );
 
     if (modificationResult.ok) {
-      log(`New Status: ${status}`, { orderId });
       if (order.status === null) {
         // The first time that an order transitions away from cart is a checkout event
         await emit('ORDER_CHECKOUT', { order: modificationResult.value, oldStatus: order.status });
@@ -149,11 +147,6 @@ export const configureOrderModuleProcessing = ({
     const validationErrors = await Promise.all(
       orderPositions.map(async (orderPosition) => {
         const errors = [];
-
-        log(`OrderPosition ${orderPosition._id} -> Validate ${orderPosition.quantity}`, {
-          orderId: orderPosition.orderId,
-        });
-
         const product = await unchainedAPI.modules.products.findProduct({
           productId: orderPosition.productId,
         });
@@ -256,7 +249,7 @@ export const configureOrderModuleProcessing = ({
   };
 
   return {
-    checkout: async (orderId, transactionContext, unchainedAPI) => {
+    checkout: async (orderId, { paymentContext, deliveryContext }, unchainedAPI) => {
       const { modules, services } = unchainedAPI;
 
       const order = await Orders.findOne(generateDbFilterById(orderId), {});
@@ -275,7 +268,10 @@ export const configureOrderModuleProcessing = ({
       try {
         const processedOrder = await modules.orders.processOrder(
           order,
-          transactionContext,
+          {
+            paymentContext,
+            deliveryContext,
+          },
           unchainedAPI,
         );
 
@@ -303,7 +299,7 @@ export const configureOrderModuleProcessing = ({
       }
     },
 
-    confirm: async (order, transactionContext, unchainedAPI) => {
+    confirm: async (order, { paymentContext, deliveryContext }, unchainedAPI) => {
       const { modules } = unchainedAPI;
 
       if (order.status !== OrderStatus.PENDING) return order;
@@ -313,7 +309,8 @@ export const configureOrderModuleProcessing = ({
         return await modules.orders.processOrder(
           order,
           {
-            ...transactionContext,
+            paymentContext,
+            deliveryContext,
             nextStatus: OrderStatus.CONFIRMED,
           },
           unchainedAPI,
@@ -323,7 +320,7 @@ export const configureOrderModuleProcessing = ({
       }
     },
 
-    reject: async (order, transactionContext, unchainedAPI) => {
+    reject: async (order, { paymentContext, deliveryContext }, unchainedAPI) => {
       const { modules } = unchainedAPI;
 
       if (order.status !== OrderStatus.PENDING) return order;
@@ -333,7 +330,8 @@ export const configureOrderModuleProcessing = ({
         return await modules.orders.processOrder(
           order,
           {
-            ...transactionContext,
+            paymentContext,
+            deliveryContext,
             nextStatus: OrderStatus.REJECTED,
           },
           unchainedAPI,
@@ -343,14 +341,9 @@ export const configureOrderModuleProcessing = ({
       }
     },
 
-    processOrder: async (initialOrder, orderTransactionContext, unchainedAPI) => {
+    processOrder: async (initialOrder, params, unchainedAPI) => {
       const { modules } = unchainedAPI;
-      const {
-        paymentContext,
-        deliveryContext,
-        nextStatus: forceNextStatus,
-        comment,
-      } = orderTransactionContext;
+      const { paymentContext, deliveryContext, nextStatus: forceNextStatus } = params;
 
       const orderId = initialOrder._id;
       let order = initialOrder;
@@ -400,7 +393,7 @@ export const configureOrderModuleProcessing = ({
           // numbers that are needed for delivery
           order = await updateStatus(orderId, {
             status: OrderStatus.CONFIRMED,
-            info: comment,
+            info: 'before delivery',
           });
 
           const orderDelivery = await modules.orders.deliveries.findDelivery({
@@ -475,17 +468,12 @@ export const configureOrderModuleProcessing = ({
               );
             }),
           );
-
-          // TODO: we will use this function to keep a "Ordered in Flight" amount, allowing us to
-          // do live stock stuff
-          // 2. Reserve quantity at Warehousing Provider until order is CANCELLED/FULLFILLED
-          // ???
         }
 
         nextStatus = await findNextStatus(nextStatus, order, unchainedAPI);
       }
 
-      return updateStatus(order._id, { status: nextStatus, info: comment });
+      return updateStatus(order._id, { status: nextStatus, info: 'order processed' });
     },
 
     updateStatus,