Merge remote-tracking branch 'origin/develop' into release/next

2021-02-25 14:38:47 +01:00
parent 7be4bb5f2d d307dfc24f
commit 63e7ce765e
7 changed files with 397 additions and 40 deletions
--- a/integration-tests/api/tests/admin/customer.js
+++ b/integration-tests/api/tests/admin/customer.js
@@ -0,0 +1,135 @@
+const { dropDatabase } = require("pg-god");
+const path = require("path");
+
+const setupServer = require("../../../helpers/setup-server");
+const { useApi } = require("../../../helpers/use-api");
+const { initDb } = require("../../../helpers/use-db");
+
+const customerSeeder = require("../../helpers/customer-seeder");
+const adminSeeder = require("../../helpers/admin-seeder");
+
+jest.setTimeout(30000);
+
+describe("/admin/customers", () => {
+  let medusaProcess;
+  let dbConnection;
+
+  beforeAll(async () => {
+    const cwd = path.resolve(path.join(__dirname, "..", ".."));
+    dbConnection = await initDb({ cwd });
+    medusaProcess = await setupServer({ cwd });
+  });
+
+  afterAll(async () => {
+    await dbConnection.close();
+    await dropDatabase({ databaseName: "medusa-integration" });
+
+    medusaProcess.kill();
+  });
+
+  describe("GET /admin/customers", () => {
+    beforeEach(async () => {
+      try {
+        await adminSeeder(dbConnection);
+        await customerSeeder(dbConnection);
+      } catch (err) {
+        console.log(err);
+        throw err;
+      }
+    });
+
+    afterEach(async () => {
+      const manager = dbConnection.manager;
+      await manager.query(`DELETE FROM "address"`);
+      await manager.query(`DELETE FROM "customer"`);
+      await manager.query(`DELETE FROM "user"`);
+    });
+
+    it("lists customers and query count", async () => {
+      const api = useApi();
+
+      const response = await api
+        .get("/admin/customers", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(response.status).toEqual(200);
+      expect(response.data.count).toEqual(3);
+      expect(response.data.customers).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: "test-customer-1",
+          }),
+          expect.objectContaining({
+            id: "test-customer-2",
+          }),
+          expect.objectContaining({
+            id: "test-customer-3",
+          }),
+        ])
+      );
+    });
+
+    it("lists customers with specific query", async () => {
+      const api = useApi();
+
+      const response = await api
+        .get("/admin/customers?q=test2@email.com", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(response.status).toEqual(200);
+      expect(response.data.count).toEqual(1);
+      expect(response.data.customers).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: "test-customer-2",
+            email: "test2@email.com",
+          }),
+        ])
+      );
+    });
+
+    it("lists customers with expand query", async () => {
+      const api = useApi();
+
+      const response = await api
+        .get("/admin/customers?q=test1@email.com&expand=shipping_addresses", {
+          headers: {
+            Authorization: "Bearer test_token",
+          },
+        })
+        .catch((err) => {
+          console.log(err);
+        });
+
+      expect(response.status).toEqual(200);
+      expect(response.data.count).toEqual(1);
+      console.log(response.data.customers);
+      expect(response.data.customers).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: "test-customer-1",
+            shipping_addresses: expect.arrayContaining([
+              expect.objectContaining({
+                id: "test-address",
+                first_name: "Lebron",
+                last_name: "James",
+              }),
+            ]),
+          }),
+        ])
+      );
+    });
+  });
+});
--- a/integration-tests/api/helpers/customer-seeder.js
+++ b/integration-tests/api/helpers/customer-seeder.js
@@ -0,0 +1,27 @@
+const { Customer, Address } = require("@medusajs/medusa");
+
+module.exports = async (connection, data = {}) => {
+  const manager = connection.manager;
+
+  await manager.insert(Customer, {
+    id: "test-customer-1",
+    email: "test1@email.com",
+  });
+
+  await manager.insert(Customer, {
+    id: "test-customer-2",
+    email: "test2@email.com",
+  });
+
+  await manager.insert(Customer, {
+    id: "test-customer-3",
+    email: "test3@email.com",
+  });
+
+  await manager.insert(Address, {
+    id: "test-address",
+    first_name: "Lebron",
+    last_name: "James",
+    customer_id: "test-customer-1",
+  });
+};
--- a/packages/medusa-plugin-brightpearl/src/services/brightpearl.js
+++ b/packages/medusa-plugin-brightpearl/src/services/brightpearl.js
@@ -5,6 +5,7 @@ import Brightpearl from "../utils/brightpearl"
 class BrightpearlService extends BaseService {
  constructor(
    {
+      manager,
      oauthService,
      totalsService,
      productVariantService,
@@ -18,6 +19,7 @@ class BrightpearlService extends BaseService {
  ) {
    super()

+    this.manager_ = manager
    this.options = options
    this.productVariantService_ = productVariantService
    this.regionService_ = regionService
@@ -189,8 +191,12 @@ class BrightpearlService extends BaseService {
        .retrieveBySKU(sku)
        .catch((_) => undefined)
      if (variant && variant.manage_inventory) {
-        await this.productVariantService_.update(variant.id, {
-          inventory_quantity: onHand,
+        await this.manager_.transaction((m) => {
+          return this.productVariantService_
+            .withTransaction(m)
+            .update(variant.id, {
+              inventory_quantity: onHand,
+            })
        })
      }
    }
--- a/packages/medusa-plugin-contentful/src/loaders/check-types.js
+++ b/packages/medusa-plugin-contentful/src/loaders/check-types.js
@@ -19,8 +19,16 @@ const checkContentTypes = async (container) => {
  if (product && product.fields) {
    const productFields = product.fields

+    const customProductFields = Object.keys(
+      contentfulService.options_.custom_product_fields || {}
+    )
    const keys = Object.values(productFields).map((f) => f.id)
-    if (!requiredProductFields.every((f) => keys.includes(f))) {
+
+    const missingKeys = requiredProductFields.filter(
+      (rpf) => !keys.includes(rpf) && !customProductFields.includes(rpf)
+    )
+
+    if (missingKeys.length) {
      throw Error(
        `Contentful: Content type ${`product`} is missing some required key(s). Required: ${requiredProductFields.join(
          ", "
@@ -32,8 +40,16 @@ const checkContentTypes = async (container) => {
  if (variant && variant.fields) {
    const variantFields = variant.fields

+    const customVariantFields = Object.keys(
+      contentfulService.options_.custom_variant_fields || {}
+    )
    const keys = Object.values(variantFields).map((f) => f.id)
-    if (!requiredVariantFields.every((f) => keys.includes(f))) {
+
+    const missingKeys = requiredVariantFields.filter(
+      (rpf) => !keys.includes(rpf) && !customVariantFields.includes(rpf)
+    )
+
+    if (missingKeys.length) {
      throw Error(
        `Contentful: Content type ${`productVariant`} is missing some required key(s). Required: ${requiredVariantFields.join(
          ", "
@@ -47,13 +63,13 @@ const requiredProductFields = [
  "title",
  "variants",
  "options",
-  "objectId",
+  "medusaId",
  "type",
  "collection",
  "tags",
  "handle",
 ]

-const requiredVariantFields = ["title", "sku", "prices", "options", "objectId"]
+const requiredVariantFields = ["title", "sku", "prices", "options", "medusaId"]

 export default checkContentTypes
--- a/packages/medusa-plugin-contentful/src/services/contentful.js
+++ b/packages/medusa-plugin-contentful/src/services/contentful.js
@@ -111,10 +111,27 @@ class ContentfulService extends BaseService {
    return assets
  }

+  getCustomField(field, type) {
+    const customOptions = this.options_[`custom_${type}_fields`]
+
+    if (customOptions) {
+      return customOptions[field] || field
+    } else {
+      return field
+    }
+  }
+
  async createProductInContentful(product) {
    try {
      const p = await this.productService_.retrieve(product.id, {
-        relations: ["variants", "options", "tags", "type", "collection"],
+        relations: [
+          "variants",
+          "options",
+          "tags",
+          "type",
+          "collection",
+          "images",
+        ],
      })

      const environment = await this.getContentfulEnvironment_()
@@ -122,46 +139,92 @@ class ContentfulService extends BaseService {
      const variantLinks = this.getVariantLinks_(variantEntries)

      const fields = {
-        title: {
+        [this.getCustomField("title", "product")]: {
          "en-US": p.title,
        },
-        variants: {
+        [this.getCustomField("variants", "product")]: {
          "en-US": variantLinks,
        },
-        options: {
+        [this.getCustomField("options", "product")]: {
          "en-US": p.options,
        },
-        objectId: {
+        [this.getCustomField("medusaId", "product")]: {
          "en-US": p.id,
        },
      }

+      if (p.images.length > 0) {
+        const imageLinks = await this.createImageAssets(product)
+
+        const thumbnailAsset = await environment.createAsset({
+          fields: {
+            title: {
+              "en-US": `${p.title}`,
+            },
+            description: {
+              "en-US": "",
+            },
+            file: {
+              "en-US": {
+                contentType: "image/xyz",
+                fileName: p.thumbnail,
+                upload: p.thumbnail,
+              },
+            },
+          },
+        })
+
+        await thumbnailAsset.processForAllLocales()
+
+        const thumbnailLink = {
+          sys: {
+            type: "Link",
+            linkType: "Asset",
+            id: thumbnailAsset.sys.id,
+          },
+        }
+
+        fields.thumbnail = {
+          "en-US": thumbnailLink,
+        }
+
+        if (imageLinks) {
+          fields.images = {
+            "en-US": imageLinks,
+          }
+        }
+      }
+
      if (p.type) {
        const type = {
          "en-US": p.type.value,
        }
-        fields.type = type
+
+        fields[this.getCustomField("type", "product")] = type
      }

      if (p.collection) {
        const collection = {
          "en-US": p.collection.title,
        }
-        fields.collection = collection
+
+        fields[this.getCustomField("collection", "product")] = collection
      }

      if (p.tags) {
        const tags = {
          "en-US": p.tags,
        }
-        fields.tags = tags
+
+        fields[this.getCustomField("tags", "product")] = tags
      }

      if (p.handle) {
        const handle = {
          "en-US": p.handle,
        }
-        fields.handle = handle
+
+        fields[this.getCustomField("handle", "product")] = handle
      }

      const result = await environment.createEntryWithId("product", p.id, {
@@ -189,19 +252,19 @@ class ContentfulService extends BaseService {
        v.id,
        {
          fields: {
-            title: {
+            [this.getCustomField("title", "variant")]: {
              "en-US": v.title,
            },
-            sku: {
+            [this.getCustomField("sku", "variant")]: {
              "en-US": v.sku,
            },
-            prices: {
+            [this.getCustomField("prices", "variant")]: {
              "en-US": v.prices,
            },
-            options: {
+            [this.getCustomField("options", "variant")]: {
              "en-US": v.options,
            },
-            objectId: {
+            [this.getCustomField("medusaId", "variant")]: {
              "en-US": v.id,
            },
          },
@@ -240,7 +303,14 @@ class ContentfulService extends BaseService {
      }

      const p = await this.productService_.retrieve(product.id, {
-        relations: ["options", "variants", "type", "collection", "tags"],
+        relations: [
+          "options",
+          "variants",
+          "type",
+          "collection",
+          "tags",
+          "images",
+        ],
      })

      const variantEntries = await this.getVariantEntries_(p.variants)
@@ -248,46 +318,86 @@ class ContentfulService extends BaseService {

      const productEntryFields = {
        ...productEntry.fields,
-        title: {
+        [this.getCustomField("title", "product")]: {
          "en-US": p.title,
        },
-        options: {
+        [this.getCustomField("options", "product")]: {
          "en-US": p.options,
        },
-        variants: {
+        [this.getCustomField("variants", "product")]: {
          "en-US": variantLinks,
        },
-        objectId: {
+        [this.getCustomField("medusaId", "product")]: {
          "en-US": p.id,
        },
      }

+      if (p.thumbnail) {
+        const thumbnailAsset = await environment.createAsset({
+          fields: {
+            title: {
+              "en-US": `${p.title}`,
+            },
+            description: {
+              "en-US": "",
+            },
+            file: {
+              "en-US": {
+                contentType: "image/xyz",
+                fileName: p.thumbnail,
+                upload: p.thumbnail,
+              },
+            },
+          },
+        })
+
+        await thumbnailAsset.processForAllLocales()
+
+        const thumbnailLink = {
+          sys: {
+            type: "Link",
+            linkType: "Asset",
+            id: thumbnailAsset.sys.id,
+          },
+        }
+
+        productEntryFields.thumbnail = {
+          "en-US": thumbnailLink,
+        }
+      }
+
      if (p.type) {
        const type = {
          "en-US": p.type.value,
        }
-        productEntryFields.type = type
+
+        productEntryFields[this.getCustomField("type", "product")] = type
      }

      if (p.collection) {
        const collection = {
          "en-US": p.collection.title,
        }
-        productEntryFields.collection = collection
+
+        productEntryFields[
+          this.getCustomField("collection", "product")
+        ] = collection
      }

      if (p.tags) {
        const tags = {
          "en-US": p.tags,
        }
-        productEntryFields.tags = tags
+
+        productEntryFields[this.getCustomField("tags", "product")] = tags
      }

      if (p.handle) {
        const handle = {
          "en-US": p.handle,
        }
-        productEntryFields.handle = handle
+
+        productEntryFields[this.getCustomField("handle", "product")] = handle
      }

      productEntry.fields = productEntryFields
@@ -333,19 +443,19 @@ class ContentfulService extends BaseService {

      const variantEntryFields = {
        ...variantEntry.fields,
-        title: {
+        [this.getCustomField("title", "variant")]: {
          "en-US": v.title,
        },
-        sku: {
+        [this.getCustomField("sku", "variant")]: {
          "en-US": v.sku,
        },
-        options: {
+        [this.getCustomField("options", "variant")]: {
          "en-US": v.options,
        },
-        prices: {
+        [this.getCustomField("prices", "variant")]: {
          "en-US": v.prices,
        },
-        objectId: {
+        [this.getCustomField("medusaId", "variant")]: {
          "en-US": v.id,
        },
      }
@@ -377,7 +487,8 @@ class ContentfulService extends BaseService {
      }

      let update = {
-        title: productEntry.fields.title["en-US"],
+        title:
+          productEntry.fields[this.getCustomField("title", "product")]["en-US"],
      }

      // Get the thumbnail, if present
@@ -421,7 +532,10 @@ class ContentfulService extends BaseService {
      const updatedVariant = await this.productVariantService_.update(
        variantId,
        {
-          title: variantEntry.fields.title["en-US"],
+          title:
+            variantEntry.fields[this.getCustomField("title", "variant")][
+              "en-US"
+            ],
        }
      )

--- a/packages/medusa/src/api/routes/admin/customers/list-customers.js
+++ b/packages/medusa/src/api/routes/admin/customers/list-customers.js
@@ -2,18 +2,32 @@ export default async (req, res) => {
  try {
    const customerService = req.scope.resolve("customerService")

-    const limit = parseInt(req.query.limit) || 10
+    const limit = parseInt(req.query.limit) || 50
    const offset = parseInt(req.query.offset) || 0

+    const selector = {}
+
+    if ("q" in req.query) {
+      selector.q = req.query.q
+    }
+
+    let expandFields = []
+    if ("expand" in req.query) {
+      expandFields = req.query.expand.split(",")
+    }
+
    const listConfig = {
-      relations: [],
+      relations: expandFields.length ? expandFields : [],
      skip: offset,
      take: limit,
    }

-    const customers = await customerService.list({}, listConfig)
+    const [customers, count] = await customerService.listAndCount(
+      selector,
+      listConfig
+    )

-    res.json({ customers, count: customers.length, offset, limit })
+    res.json({ customers, count, offset, limit })
  } catch (error) {
    throw error
  }
--- a/packages/medusa/src/services/customer.js
+++ b/packages/medusa/src/services/customer.js
@@ -3,6 +3,7 @@ import Scrypt from "scrypt-kdf"
 import _ from "lodash"
 import { Validator, MedusaError } from "medusa-core-utils"
 import { BaseService } from "medusa-interfaces"
+import { Brackets } from "typeorm"

 /**
 * Provides layer to manipulate customers.
@@ -132,6 +133,50 @@ class CustomerService extends BaseService {
    return customerRepo.find(query)
  }

+  async listAndCount(
+    selector,
+    config = { relations: [], skip: 0, take: 50, order: { created_at: "DESC" } }
+  ) {
+    const customerRepo = this.manager_.getCustomRepository(
+      this.customerRepository_
+    )
+
+    let q
+    if ("q" in selector) {
+      q = selector.q
+      delete selector.q
+    }
+
+    const query = this.buildQuery_(selector, config)
+
+    if (q) {
+      const where = query.where
+
+      delete where.email
+      delete where.first_name
+      delete where.last_name
+
+      query.join = {
+        alias: "customer",
+      }
+
+      query.where = qb => {
+        qb.where(where)
+
+        qb.andWhere(
+          new Brackets(qb => {
+            qb.where(`customer.first_name ILIKE :q`, { q: `%${q}%` })
+              .orWhere(`customer.last_name ILIKE :q`, { q: `%${q}%` })
+              .orWhere(`customer.email ILIKE :q`, { q: `%${q}%` })
+          })
+        )
+      }
+    }
+
+    const [customers, count] = await customerRepo.findAndCount(query)
+    return [customers, count]
+  }
+
  /**
   * Return the total number of documents in database
   * @return {Promise} the result of the count operation