feat(CTC-140): Add base controller/processor for published product

event/package.json

@@ -63,7 +63,7 @@
     "@commercetools-backend/loggers": "22.28.0",
     "@commercetools/platform-sdk": "7.9.0",
     "@commercetools/sdk-client-v2": "2.5.0",
-    "@fulfillmenttools/fulfillmenttools-sdk-typescript": "0.1.16",
+    "@fulfillmenttools/fulfillmenttools-sdk-typescript": "0.1.17",
     "body-parser": "1.20.2",
     "date-fns": "2.30.0",
     "dotenv": "16.4.5",

event/src/channel/channelProcessor.ts

@@ -7,7 +7,9 @@ export class ChannelProcessor {
 
   async processChannel(message: Message & { notificationType?: string }): Promise<void> {
     if (message.resource?.typeId != 'channel') {
-      logger.warn(`Could not process CT message - resource.typeId '${message.resource?.typeId}' != 'channel'`);
+      logger.warn(
+        `Could not process CT message '${message.resource?.id}' - resource.typeId '${message.resource?.typeId}' != 'channel'`
+      );
       return;
     }
 

event/src/connector/actions.ts

@@ -2,36 +2,14 @@ import { ByProjectKeyRequestBuilder } from '@commercetools/platform-sdk/dist/dec
 
 const ORDER_SUBSCRIPTION_KEY = 'fft-ctc-orders';
 const CHANNEL_RESOURCE_SUBSCRIPTION_KEY = 'fft-ctc-channels';
+const PRODUCT_SUBSCRIPTION_KEY = 'fft-ctc-products';
 
 export async function createOrderSubscription(
   apiRoot: ByProjectKeyRequestBuilder,
   topicName: string,
   projectId: string
 ): Promise<void> {
-  const {
-    body: { results: subscriptions },
-  } = await apiRoot
-    .subscriptions()
-    .get({
-      queryArgs: {
-        where: `key = "${ORDER_SUBSCRIPTION_KEY}"`,
-      },
-    })
-    .execute();
-
-  if (subscriptions.length > 0) {
-    const subscription = subscriptions[0];
-
-    await apiRoot
-      .subscriptions()
-      .withKey({ key: ORDER_SUBSCRIPTION_KEY })
-      .delete({
-        queryArgs: {
-          version: subscription?.version || 0,
-        },
-      })
-      .execute();
-  }
+  await deleteOrderSubscription(apiRoot);
 
   await apiRoot
     .subscriptions()
@@ -55,90 +33,80 @@ export async function createOrderSubscription(
 }
 
 export async function deleteOrderSubscription(apiRoot: ByProjectKeyRequestBuilder): Promise<void> {
-  const {
-    body: { results: subscriptions },
-  } = await apiRoot
-    .subscriptions()
-    .get({
-      queryArgs: {
-        where: `key = "${ORDER_SUBSCRIPTION_KEY}"`,
-      },
-    })
-    .execute();
-
-  if (subscriptions.length > 0) {
-    const subscription = subscriptions[0];
-
-    await apiRoot
-      .subscriptions()
-      .withKey({ key: ORDER_SUBSCRIPTION_KEY })
-      .delete({
-        queryArgs: {
-          version: subscription?.version || 0,
-        },
-      })
-      .execute();
-  }
+  await deleteSubscription(ORDER_SUBSCRIPTION_KEY, apiRoot);
 }
 
 export async function createChannelResourceSubscription(
   apiRoot: ByProjectKeyRequestBuilder,
   topicName: string,
   projectId: string
 ): Promise<void> {
-  const {
-    body: { results: subscriptions },
-  } = await apiRoot
+  await deleteChannelResourceSubscription(apiRoot);
+
+  await apiRoot
     .subscriptions()
-    .get({
-      queryArgs: {
-        where: `key = "${CHANNEL_RESOURCE_SUBSCRIPTION_KEY}"`,
+    .post({
+      body: {
+        key: CHANNEL_RESOURCE_SUBSCRIPTION_KEY,
+        destination: {
+          type: 'GoogleCloudPubSub',
+          topic: topicName,
+          projectId,
+        },
+        changes: [
+          {
+            resourceTypeId: 'channel',
+          },
+        ],
       },
     })
     .execute();
+}
 
-  if (subscriptions.length > 0) {
-    const subscription = subscriptions[0];
+export async function deleteChannelResourceSubscription(apiRoot: ByProjectKeyRequestBuilder): Promise<void> {
+  await deleteSubscription(CHANNEL_RESOURCE_SUBSCRIPTION_KEY, apiRoot);
+}
 
-    await apiRoot
-      .subscriptions()
-      .withKey({ key: CHANNEL_RESOURCE_SUBSCRIPTION_KEY })
-      .delete({
-        queryArgs: {
-          version: subscription?.version || 0,
-        },
-      })
-      .execute();
-  }
+export async function createProductSubscription(
+  apiRoot: ByProjectKeyRequestBuilder,
+  topicName: string,
+  projectId: string
+): Promise<void> {
+  await deleteProductSubscription(apiRoot);
 
   await apiRoot
     .subscriptions()
     .post({
       body: {
-        key: CHANNEL_RESOURCE_SUBSCRIPTION_KEY,
+        key: PRODUCT_SUBSCRIPTION_KEY,
         destination: {
           type: 'GoogleCloudPubSub',
           topic: topicName,
           projectId,
         },
-        changes: [
+        messages: [
           {
-            resourceTypeId: 'channel',
+            resourceTypeId: 'product',
+            types: ['ProductPublished'],
           },
         ],
       },
     })
     .execute();
 }
 
-export async function deleteChannelResourceSubscription(apiRoot: ByProjectKeyRequestBuilder): Promise<void> {
+export async function deleteProductSubscription(apiRoot: ByProjectKeyRequestBuilder): Promise<void> {
+  await deleteSubscription(PRODUCT_SUBSCRIPTION_KEY, apiRoot);
+}
+
+async function deleteSubscription(key: string, apiRoot: ByProjectKeyRequestBuilder): Promise<void> {
   const {
     body: { results: subscriptions },
   } = await apiRoot
     .subscriptions()
     .get({
       queryArgs: {
-        where: `key = "${CHANNEL_RESOURCE_SUBSCRIPTION_KEY}"`,
+        where: `key = "${key}"`,
       },
     })
     .execute();
@@ -148,7 +116,7 @@ export async function deleteChannelResourceSubscription(apiRoot: ByProjectKeyReq
 
     await apiRoot
       .subscriptions()
-      .withKey({ key: CHANNEL_RESOURCE_SUBSCRIPTION_KEY })
+      .withKey({ key })
       .delete({
         queryArgs: {
           version: subscription?.version || 0,

event/src/connector/post-deploy.ts

@@ -2,7 +2,7 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { assertString, assertError, createApiRoot } from 'shared';
-import { createChannelResourceSubscription, createOrderSubscription } from './actions';
+import { createChannelResourceSubscription, createOrderSubscription, createProductSubscription } from './actions';
 
 const CONNECT_GCP_TOPIC_NAME_KEY = 'CONNECT_GCP_TOPIC_NAME';
 const CONNECT_GCP_PROJECT_ID_KEY = 'CONNECT_GCP_PROJECT_ID';
@@ -15,7 +15,7 @@ async function postDeploy(properties: Map<string, unknown>): Promise<void> {
   assertString(projectId, CONNECT_GCP_PROJECT_ID_KEY);
 
   const apiRoot = createApiRoot();
-  const actions = [createOrderSubscription, createChannelResourceSubscription];
+  const actions = [createOrderSubscription, createProductSubscription, createChannelResourceSubscription];
   await Promise.all(actions.map(async (a) => await a(apiRoot, topicName, projectId)));
 }
 

event/src/connector/pre-undeploy.ts

@@ -2,11 +2,11 @@ import dotenv from 'dotenv';
 dotenv.config();
 
 import { assertError, createApiRoot } from 'shared';
-import { deleteChannelResourceSubscription, deleteOrderSubscription } from './actions';
+import { deleteChannelResourceSubscription, deleteOrderSubscription, deleteProductSubscription } from './actions';
 
 async function preUndeploy(): Promise<void> {
   const apiRoot = createApiRoot();
-  const actions = [deleteOrderSubscription, deleteChannelResourceSubscription];
+  const actions = [deleteOrderSubscription, deleteProductSubscription, deleteChannelResourceSubscription];
   await Promise.all(actions.map(async (a) => await a(apiRoot)));
 }
 

event/src/controllers/eventController.ts

@@ -1,12 +1,23 @@
 import { NextFunction, Request, Response } from 'express';
-import { Message, OrderCreatedMessage, OrderStateChangedMessage, Reference } from '@commercetools/platform-sdk';
+import {
+  Message,
+  OrderCreatedMessage,
+  OrderStateChangedMessage,
+  ProductPublishedMessage,
+  Reference,
+} from '@commercetools/platform-sdk';
 
 import { logger, CustomError, SubscriptionMessage } from 'shared';
 import { OrderProcessor } from '../order/orderProcessor';
 import { ChannelProcessor } from '../channel/channelProcessor';
+import { ProductProcessor } from '../product/productProcessor';
 
 export class EventController {
-  constructor(private readonly orderProcessor: OrderProcessor, private readonly channelProcessor: ChannelProcessor) {
+  constructor(
+    private readonly orderProcessor: OrderProcessor,
+    private readonly productProcessor: ProductProcessor,
+    private readonly channelProcessor: ChannelProcessor
+  ) {
     this.post = this.post.bind(this);
   }
 
@@ -36,6 +47,11 @@ export class EventController {
           await this.orderProcessor.cancelOrder(resourceRef.id, message.resourceUserProvidedIdentifiers?.orderNumber);
         }
         break;
+      case 'product':
+        if (this.isProductPublishedMessage(message)) {
+          await this.productProcessor.processProductPublished(message as ProductPublishedMessage);
+        }
+        break;
       case 'channel':
         if (this.isChannelMessage(message)) {
           await this.channelProcessor.processChannel(message);
@@ -129,4 +145,8 @@ export class EventController {
       notificationType === 'ResourceDeleted'
     );
   }
+
+  private isProductPublishedMessage(message: Message): boolean {
+    return message.type === 'ProductPublished';
+  }
 }

event/src/order/orderMapper.ts

@@ -112,7 +112,8 @@
   }
 
   private mapOrderLineItems(commercetoolsOrder: CommercetoolsOrder): OrderLineItemForCreation[] {
     function getStringValue(value: { [key: string]: any }): string {
+      // TODO map languages defined in CT project using ProjectService.getProject
       const locales = ['en-US', 'en-GB', 'en-AU', 'en-CA', 'en', 'de-DE', 'de-AT', 'de-CH', 'de'];
       let result: string | undefined = undefined;
       for (const locale of locales) {
@@ -127,7 +128,7 @@
       return result || ' ';
     }
 
     function mapAttributeValue(value: any): string {
       if (value === undefined || value === null) {
         return ' '; // FFT API does not allow empty attribute value;
       } else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {

event/src/product/productMapper.ts

@@ -0,0 +1,75 @@
+import { ProductProjection, ProductVariant } from '@commercetools/platform-sdk';
+import {
+  ArticleAttributeItem,
+  ListingAttributeItem,
+  ListingForReplacement,
+  LocaleString,
+} from '@fulfillmenttools/fulfillmenttools-sdk-typescript';
+
+export class ProductMapper {
+  public async mapProduct(
+    product: ProductProjection,
+    languages: string[],
+    tenantArticleId: string
+  ): Promise<ListingForReplacement | undefined> {
+    const variant = this.getVariant(product, tenantArticleId);
+    if (!variant) {
+      return undefined;
+    }
+
+    const listing: ListingForReplacement = {
+      tenantArticleId,
+      title: 'title', // will be overwritten by localized title
+    };
+
+    const titleLocalized: LocaleString = {};
+    for (const language of languages) {
+      if (product.name[language]) {
+        titleLocalized[this.mapLocale(language)] = product.name[language];
+      }
+    }
+    listing.titleLocalized = titleLocalized;
+
+    const attr: ListingAttributeItem = {
+      category: ArticleAttributeItem.CategoryEnum.Descriptive,
+      key: '%%subtitle%%',
+      value: 'value', // will be overwritten by localized value
+    };
+
+    const valueLocalized: LocaleString = {};
+    for (const language of languages) {
+      if (product.description?.[language]) {
+        valueLocalized[this.mapLocale(language)] = product.description[language];
+      }
+    }
+    attr.valueLocalized = valueLocalized;
+
+    listing.attributes = [attr];
+
+    if (variant.images !== undefined && variant.images.length > 0) {
+      listing.imageUrl = variant.images[0].url;
+    }
+
+    listing.customAttributes = {
+      ctProductId: product.id,
+      ctProductVariant: variant.id,
+    };
+
+    if (product.key) {
+      listing.customAttributes.ctProductKey = product.key;
+    }
+
+    return listing;
+  }
+
+  getVariant(product: ProductProjection, tenantArticleId: string): ProductVariant | undefined {
+    if (product.masterVariant.sku === tenantArticleId) {
+      return product.masterVariant;
+    }
+    return product.variants.find((variant) => variant.sku === tenantArticleId);
+  }
+
+  mapLocale(source: string): string {
+    return source.replace('-', '_');
+  }
+}