Merge branch 'release-0.9.4'

Author: batamar

.gitignore

@@ -5,3 +5,4 @@ static
 npm-debug.log*
 .env
 coverage
+dump.rdb

README.md

@@ -5,7 +5,7 @@
 
 This repository is the main web app of the erxes platform that consists of 2 other repositories:
 
-- [Flatform](https://github.com/erxes/erxes)
+- [Erxes](https://github.com/erxes/erxes)
 - [Widgets](https://github.com/erxes/erxes-widgets)
 
 Clone erxes repository and install its dependencies:

package.json

@@ -1,6 +1,6 @@
 {
   "name": "erxes-app-api",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "GraphQL API for erxes main project",
   "homepage": "https://erxes.io",
   "repository": "https://github.com/erxes/erxes-app-api",
@@ -51,13 +51,14 @@
     "fbgraph": "^1.4.1",
     "formidable": "^1.1.1",
     "graphql": "^0.10.1",
-    "graphql-redis-subscriptions": "^1.3.1",
+    "graphql-redis-subscriptions": "^1.4.0",
     "graphql-server-core": "^0.8.2",
     "graphql-server-express": "^0.8.2",
     "graphql-server-module-graphiql": "^0.8.2",
     "graphql-subscriptions": "^0.4.4",
     "graphql-tools": "^1.0.0",
     "handlebars": "^4.0.10",
+    "ioredis": "^3.2.2",
     "jsonwebtoken": "^8.1.0",
     "meteor-random": "^0.0.3",
     "moment": "^2.18.1",

src/__tests__/activityLogDb.test.js

@@ -125,6 +125,24 @@ describe('ActivityLogs model methods', () => {
     });
   });
 
+  test(`Testing found segment`, async () => {
+    const segment = await segmentFactory({});
+    const customer = await customerFactory({});
+    await ActivityLogs.createSegmentLog(segment, customer);
+
+    await ActivityLogs.createSegmentLog(segment, customer);
+
+    expect(
+      await ActivityLogs.find({
+        'activity.type': ACTIVITY_TYPES.SEGMENT,
+        'activity.action': ACTIVITY_ACTIONS.CREATE,
+        'activity.id': segment._id,
+        'coc.type': segment.contentType,
+        'coc.id': customer._id,
+      }),
+    ).toHaveLength(1);
+  });
+
   test(`check if exceptions are being thrown as intended when
     calling createConversationLog`, async () => {
     expect.assertions(2);
@@ -151,7 +169,9 @@ describe('ActivityLogs model methods', () => {
     const conversation = await conversationFactory({});
     const companyA = await companyFactory({});
     const companyB = await companyFactory({});
-    const customer = await customerFactory({ companyIds: [companyA._id, companyB._id] });
+    const customer = await customerFactory({
+      companyIds: [companyA._id, companyB._id],
+    });
 
     let aLog = await ActivityLogs.createConversationLog(conversation, customer);
 
@@ -245,4 +265,74 @@ describe('ActivityLogs model methods', () => {
       id: company._id,
     });
   });
+
+  test(`changeCustomer`, async () => {
+    const customer = await customerFactory({});
+    const newCustomer = await customerFactory({});
+    const conversation = await conversationFactory({});
+
+    await ActivityLogs.createConversationLog(conversation, customer);
+
+    const aLogs = await ActivityLogs.changeCustomer(newCustomer._id, [customer._id]);
+
+    for (let aLog of aLogs) {
+      expect(aLog.coc.toObject()).toEqual({
+        type: COC_CONTENT_TYPES.CUSTOMER,
+        id: newCustomer._id,
+      });
+    }
+  });
+
+  test(`changeCompany`, async () => {
+    const company = await companyFactory({});
+    const newCompany = await companyFactory({});
+    const user = await userFactory({});
+
+    await ActivityLogs.createCompanyRegistrationLog(company, user);
+
+    const aLogs = await ActivityLogs.changeCompany(newCompany._id, [company._id]);
+
+    for (let aLog of aLogs) {
+      expect(aLog.coc.toObject()).toEqual({
+        type: COC_CONTENT_TYPES.COMPANY,
+        id: newCompany._id,
+      });
+    }
+  });
+
+  test(`removeCustomerActivityLog`, async () => {
+    const customer = await customerFactory({});
+    const conversation = await conversationFactory({});
+
+    await ActivityLogs.createConversationLog(conversation, customer);
+    const removed = await ActivityLogs.removeCustomerActivityLog(customer._id);
+
+    const activityLog = await ActivityLogs.find({
+      coc: {
+        type: COC_CONTENT_TYPES.CUSTOMER,
+        id: customer._id,
+      },
+    });
+
+    expect(activityLog).toHaveLength(0);
+    expect(removed.result).toEqual({ ok: 1, n: 1 });
+  });
+
+  test(`removeCompanyActivityLog`, async () => {
+    const company = await companyFactory({});
+    const user = await userFactory({});
+
+    await ActivityLogs.createCompanyRegistrationLog(company, user);
+    const removed = await ActivityLogs.removeCompanyActivityLog(company._id);
+
+    const activityLog = await ActivityLogs.find({
+      coc: {
+        type: COC_CONTENT_TYPES.COMPANY,
+        id: company._id,
+      },
+    });
+
+    expect(activityLog).toHaveLength(0);
+    expect(removed.result).toEqual({ ok: 1, n: 1 });
+  });
 });

src/__tests__/brandDb.test.js

@@ -2,8 +2,8 @@
 /* eslint-disable no-underscore-dangle */
 
 import { connect, disconnect } from '../db/connection';
-import { Brands, Users } from '../db/models';
-import { brandFactory, userFactory } from '../db/factories';
+import { Brands, Users, Integrations } from '../db/models';
+import { brandFactory, userFactory, integrationFactory } from '../db/factories';
 
 beforeAll(() => connect());
 
@@ -81,4 +81,22 @@ describe('Brands db', () => {
     expect(brandObj.emailConfig.type).toBe(_brand.emailConfig.type);
     expect(brandObj.emailConfig.template).toBe(_brand.emailConfig.template);
   });
+
+  test('Manage integrations', async () => {
+    const brand = await brandFactory({});
+
+    let integration1 = await integrationFactory({});
+    let integration2 = await integrationFactory({});
+
+    await Brands.manageIntegrations({
+      _id: brand._id,
+      integrationIds: [integration1._id, integration2._id],
+    });
+
+    integration1 = await Integrations.findOne({ _id: integration1._id });
+    integration2 = await Integrations.findOne({ _id: integration2._id });
+
+    expect(integration1.brandId).toBe(brand._id);
+    expect(integration2.brandId).toBe(brand._id);
+  });
 });

src/__tests__/brandMutations.test.js

@@ -113,4 +113,15 @@ describe('Brands mutations', () => {
     expect(Brands.updateEmailConfig.mock.calls.length).toBe(1);
     expect(Brands.updateEmailConfig).toBeCalledWith(_brand._id, _brand.emailConfig);
   });
+
+  test('Manage integrations', async () => {
+    Brands.manageIntegrations = jest.fn();
+
+    const args = { _id: _brand._id, integrationIds: ['_id1', '_id2'] };
+
+    await brandMutations.brandsManageIntegrations({}, args, { user: _adminUser });
+
+    expect(Brands.manageIntegrations.mock.calls.length).toBe(1);
+    expect(Brands.manageIntegrations).toBeCalledWith(args);
+  });
 });

src/__tests__/companyDb.test.js

@@ -2,8 +2,15 @@
 /* eslint-disable no-underscore-dangle */
 
 import { connect, disconnect } from '../db/connection';
-import { Companies } from '../db/models';
-import { companyFactory, fieldFactory } from '../db/factories';
+import { Companies, Customers, InternalNotes, ActivityLogs } from '../db/models';
+import {
+  companyFactory,
+  fieldFactory,
+  internalNoteFactory,
+  activityLogFactory,
+  customerFactory,
+} from '../db/factories';
+import { COC_CONTENT_TYPES } from '../data/constants';
 
 beforeAll(() => connect());
 
@@ -121,4 +128,158 @@ describe('Companies model tests', () => {
       expect(e.message).toBe(`${field.text}: Invalid number`);
     }
   });
+
+  test('Update company customers', async () => {
+    const customerIds = ['12313qwrqwe', '123', '11234'];
+
+    await Companies.updateCustomers(_company._id, customerIds);
+
+    for (let customerId of customerIds) {
+      const customerObj = await Customers.findOne({ _id: customerId });
+
+      expect(customerObj.companyIds).toContain(_company._id);
+    }
+  });
+
+  test('removeCompany', async () => {
+    const company = await companyFactory({});
+    await customerFactory({ companyIds: [company._id] });
+
+    await internalNoteFactory({
+      contentType: COC_CONTENT_TYPES.COMPANY,
+      contentTypeId: company._id,
+    });
+
+    const removed = await Companies.removeCompany(company._id);
+
+    const internalNote = await InternalNotes.find({
+      contentType: COC_CONTENT_TYPES.COMPANY,
+      contentTypeId: company._id,
+    });
+
+    const activityLog = await ActivityLogs.find({
+      coc: {
+        type: COC_CONTENT_TYPES.COMPANY,
+        id: company._id,
+      },
+    });
+
+    const customers = await Customers.find({ companyIds: { $in: [company._id] } });
+
+    expect(customers).toHaveLength(0);
+    expect(internalNote).toHaveLength(0);
+    expect(activityLog).toHaveLength(0);
+    expect(removed.result).toEqual({ n: 1, ok: 1 });
+  });
+
+  test('mergeCompanies', async () => {
+    const testCompany = await companyFactory({
+      tagIds: ['123', '456', '1234'],
+    });
+
+    const testCompany2 = await companyFactory({
+      tagIds: ['1231', '123', 'asd12'],
+    });
+
+    let testCustomer = await customerFactory({
+      companyIds: [testCompany._id],
+    });
+
+    let testCustomer2 = await customerFactory({
+      companyIds: [testCompany2._id],
+    });
+
+    const companyIds = [testCompany._id, testCompany2._id];
+    const mergedTagIds = Array.from(new Set(testCompany.tagIds.concat(testCompany2.tagIds)));
+
+    // test duplication
+    try {
+      await Companies.mergeCompanies(companyIds, { name: _company.name });
+    } catch (e) {
+      expect(e.message).toBe('Duplicated name');
+    }
+
+    await internalNoteFactory({
+      contentType: COC_CONTENT_TYPES.COMPANY,
+      contentTypeId: companyIds[0],
+    });
+
+    await activityLogFactory({
+      coc: {
+        type: COC_CONTENT_TYPES.COMPANY,
+        id: companyIds[0],
+      },
+    });
+
+    const doc = {
+      name: 'Test name',
+      website: 'Test webiste',
+      size: 230,
+      industry: 'Test industry',
+      plan: 'Test plan',
+    };
+
+    const updatedCompany = await Companies.mergeCompanies(companyIds, doc);
+
+    expect(updatedCompany.name).toBe(doc.name);
+    expect(updatedCompany.website).toBe(doc.website);
+    expect(updatedCompany.size).toBe(doc.size);
+    expect(updatedCompany.industry).toBe(doc.industry);
+    expect(updatedCompany.plan).toBe(doc.plan);
+
+    // Checking old company datas deleted
+    expect(await Companies.find({ _id: companyIds[0] })).toHaveLength(0);
+    expect(updatedCompany.tagIds).toEqual(expect.arrayContaining(mergedTagIds));
+
+    testCustomer = await Customers.findOne({ _id: testCustomer._id });
+    expect(testCustomer.companyIds).not.toContain(testCompany._id);
+
+    testCustomer2 = await Customers.findOne({ _id: testCustomer2._id });
+    expect(testCustomer2.companyIds).not.toContain(testCompany2._id);
+
+    let internalNote = await InternalNotes.find({
+      contentType: COC_CONTENT_TYPES.COMPANY,
+      contentTypeId: companyIds[0],
+    });
+
+    let activityLog = await ActivityLogs.find({
+      coc: {
+        type: COC_CONTENT_TYPES.COMPANY,
+        id: companyIds[0],
+      },
+    });
+
+    expect(internalNote).toHaveLength(0);
+    expect(activityLog).toHaveLength(0);
+
+    // Checking new company datas updated
+    expect(updatedCompany.tagIds).toEqual(expect.arrayContaining(mergedTagIds));
+
+    expect(testCustomer.companyIds).toContain(updatedCompany._id);
+    expect(testCustomer2.companyIds).toContain(updatedCompany._id);
+
+    internalNote = await InternalNotes.find({
+      contentType: COC_CONTENT_TYPES.COMPANY,
+      contentTypeId: updatedCompany._id,
+    });
+
+    activityLog = await ActivityLogs.find({
+      coc: {
+        type: COC_CONTENT_TYPES.COMPANY,
+        id: updatedCompany._id,
+      },
+    });
+
+    expect(internalNote).not.toHaveLength(0);
+    expect(activityLog).not.toHaveLength(0);
+  });
+
+  test('Check Duplication', async () => {
+    // check duplication
+    try {
+      await Companies.checkDuplication({ name: _company.name }, '123132');
+    } catch (e) {
+      expect(e.message).toBe('Duplicated name');
+    }
+  });
 });