Merge branch 'master' of https://github.com/abouolia/Bigcapital

server/package.json

@@ -27,6 +27,7 @@
     "bookshelf-modelbase": "^2.10.4",
     "bookshelf-paranoia": "^0.13.1",
     "compression": "^1.7.4",
+    "country-codes-list": "^1.6.8",
     "crypto-random-string": "^3.2.0",
     "csurf": "^1.10.0",
     "deep-map": "^2.0.0",
@@ -48,6 +49,7 @@
     "knex": "^0.20.3",
     "knex-cleaner": "^1.3.0",
     "knex-db-manager": "^0.6.1",
+    "libphonenumber-js": "^1.9.6",
     "lodash": "^4.17.15",
     "memory-cache": "^0.2.0",
     "moment": "^2.24.0",

server/src/api/controllers/Authentication.ts

@@ -1,6 +1,8 @@
 import { Request, Response, Router } from 'express';
 import { check, ValidationChain } from 'express-validator';
 import { Service, Inject } from 'typedi';
+import countries from 'country-codes-list';
+import parsePhoneNumber from 'libphonenumber-js';
 import BaseController from 'api/controllers/BaseController';
 import asyncMiddleware from 'api/middleware/asyncMiddleware';
 import AuthenticationService from 'services/Authentication';
@@ -8,6 +10,7 @@ import { ILoginDTO, ISystemUser, IRegisterOTD } from 'interfaces';
 import { ServiceError, ServiceErrors } from "exceptions";
 import { DATATYPES_LENGTH } from 'data/DataTypes';
 import LoginThrottlerMiddleware from 'api/middleware/LoginThrottlerMiddleware';
+import config from 'config';
 
 @Service()
 export default class AuthenticationController extends BaseController{
@@ -63,15 +66,84 @@ export default class AuthenticationController extends BaseController{
    */
   get registerSchema(): ValidationChain[] {
     return [
-      check('first_name').exists().isString().trim().escape().isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('first_name')
-      check('last_name').exists().isString().trim().escape().isLength({ max: DATATYPES_LENGTH.STRING }),
+        .exists()
-      check('email').exists().isString().isEmail().trim().escape().isLength({ max: DATATYPES_LENGTH.STRING }),
+        .isString()
-      check('phone_number').exists().isString().trim().escape().isLength({ max: DATATYPES_LENGTH.STRING }),
+        .trim()
-      check('password').exists().isString().trim().escape().isLength({ max: DATATYPES_LENGTH.STRING }),
+        .escape()
-      check('country').exists().isString().trim().escape().isLength({ max: DATATYPES_LENGTH.STRING }),
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('last_name')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('email')
+        .exists()
+        .isString()
+        .isEmail()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('phone_number')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .custom(this.phoneNumberValidator)
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('password')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
+      check('country')
+        .exists()
+        .isString()
+        .trim()
+        .escape()
+        .custom(this.countryValidator)
+        .isLength({ max: DATATYPES_LENGTH.STRING }),
     ];
   }
 
+  /**
+   * Country validator.
+   */
+  countryValidator(value, { req }) {
+    const { countries: { whitelist, blacklist } } = config.registration;
+    const foundCountry = countries.findOne('countryCode', value);
+
+    if (!foundCountry) {
+      throw new Error('The country code is invalid.');
+    }
+    if (
+      // Focus with me! In case whitelist is not empty and the given coutry is not 
+      // in whitelist throw the error.
+      // 
+      // Or in case the blacklist is not empty and the given country exists 
+      // in the blacklist throw the goddamn error.
+      (whitelist.length > 0 && whitelist.indexOf(value) === -1) || 
+      (blacklist.length > 0 && blacklist.indexOf(value) !== -1)
+    ) {
+      throw new Error('The country code is not supported yet.');
+    }
+    return true;
+  }
+
+  /**
+   * Phone number validator.
+   */
+  phoneNumberValidator(value, { req }) {
+    const phoneNumber = parsePhoneNumber(value, req.body.country);
+
+    if (!phoneNumber || !phoneNumber.isValid()) {
+      throw new Error('Phone number is invalid with the given country code.');
+    }
+    return true;
+  }
+
   /**
    * Reset password schema.
    */

server/src/api/controllers/Items.ts

@@ -30,6 +30,22 @@ export default class ItemsController extends BaseController {
       asyncMiddleware(this.newItem.bind(this)),
       this.handlerServiceErrors,
     );
+    router.post(
+      '/:id/activate', [
+      ...this.validateSpecificItemSchema,
+    ],
+      this.validationResult,
+      asyncMiddleware(this.activateItem.bind(this)),
+      this.handlerServiceErrors
+    );
+    router.post(
+      '/:id/inactivate', [
+        ...this.validateSpecificItemSchema,
+    ],
+      this.validationResult,
+      asyncMiddleware(this.inactivateItem.bind(this)),
+      this.handlerServiceErrors,
+    )
     router.post(
       '/:id', [
       ...this.validateItemSchema,
@@ -170,7 +186,7 @@ export default class ItemsController extends BaseController {
    */
   get validateBulkSelectSchema(): ValidationChain[] {
     return [
-      query('ids').isArray({ min: 2 }),
+      query('ids').isArray({ min: 1 }),
       query('ids.*').isNumeric().toInt(),
     ];
   }
@@ -226,6 +242,50 @@ export default class ItemsController extends BaseController {
     }
   }
 
+  /**
+   * Activates the given item.
+   * @param {Request} req 
+   * @param {Response} res 
+   * @param {NextFunction} next 
+   */
+  async activateItem(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const itemId: number = req.params.id;
+
+    try {
+      await this.itemsService.activateItem(tenantId, itemId);
+
+      return res.status(200).send({
+        id: itemId,
+        message: 'The item has been activated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
+  /**
+   * Inactivates the given item.
+   * @param {Request} req 
+   * @param {Response} res 
+   * @param {NextFunction} next 
+   */
+  async inactivateItem(req: Request, res: Response, next: NextFunction) {
+    const { tenantId } = req;
+    const itemId: number = req.params.id;
+
+    try {
+      await this.itemsService.inactivateItem(tenantId, itemId);
+
+      return res.status(200).send({
+        id: itemId,
+        message: 'The item has been inactivated successfully.',
+      });
+    } catch (error) {
+      next(error);
+    }
+  }
+
   /**
    * Deletes the given item from the storage.
    * @param {Request} req 
@@ -258,6 +318,8 @@ export default class ItemsController extends BaseController {
 
       return res.status(200).send({ item: storedItem });
     } catch (error) {
+      console.log(error);
+
       next(error)
     }
   }
@@ -309,7 +371,11 @@ export default class ItemsController extends BaseController {
   
     try {
       await this.itemsService.bulkDeleteItems(tenantId, itemsIds);
-      return res.status(200).send({ ids: itemsIds });
+
+      return res.status(200).send({
+        ids: itemsIds,
+        message: 'Items have been deleted successfully.',
+      });
     } catch (error) {
       next(error);
     }

server/src/config/index.js

@@ -144,5 +144,17 @@ export default {
       duration: 60,
       blockDuration: 60 * 10,
     }
+  },
+
+  /**
+   * Users registeration configuration.
+   */
+  registration: {
+    countries: {
+      whitelist: [
+        'LY',
+      ],
+      blacklist: [],
+    }
   }
 };

server/src/services/Items/ItemsService.ts

@@ -1,9 +1,9 @@
-import { defaultTo, difference } from "lodash";
+import { defaultTo, difference } from 'lodash';
-import { Service, Inject } from "typedi";
+import { Service, Inject } from 'typedi';
 import { IItemsFilter, IItemsService, IItemDTO, IItem } from 'interfaces';
 import DynamicListingService from 'services/DynamicListing/DynamicListService';
 import TenancyService from 'services/Tenancy/TenancyService';
-import { ServiceError } from "exceptions";
+import { ServiceError } from 'exceptions';
 
 const ERRORS = {
   NOT_FOUND: 'NOT_FOUND',
@@ -18,7 +18,7 @@ const ERRORS = {
   INVENTORY_ACCOUNT_NOT_INVENTORY: 'INVENTORY_ACCOUNT_NOT_INVENTORY',
 
   ITEMS_HAVE_ASSOCIATED_TRANSACTIONS: 'ITEMS_HAVE_ASSOCIATED_TRANSACTIONS',
-  ITEM_HAS_ASSOCIATED_TRANSACTINS: 'ITEM_HAS_ASSOCIATED_TRANSACTINS'
+  ITEM_HAS_ASSOCIATED_TRANSACTINS: 'ITEM_HAS_ASSOCIATED_TRANSACTINS',
 };
 
 @Service()
@@ -38,7 +38,10 @@ export default class ItemsService implements IItemsService {
    * @param {number} itemId
    * @return {Promise<void>}
    */
-  private async getItemOrThrowError(tenantId: number, itemId: number): Promise<void> {
+  private async getItemOrThrowError(
+    tenantId: number,
+    itemId: number
+  ): Promise<void> {
     const { Item } = this.tenancy.models(tenantId);
 
     this.logger.info('[items] validate item id existance.', { itemId });
@@ -58,10 +61,17 @@ export default class ItemsService implements IItemsService {
    * @param {number} notItemId
    * @return {Promise<void>}
    */
-  private async validateItemNameUniquiness(tenantId: number, itemName: string, notItemId?: number): Promise<void> {
+  private async validateItemNameUniquiness(
+    tenantId: number,
+    itemName: string,
+    notItemId?: number
+  ): Promise<void> {
     const { Item } = this.tenancy.models(tenantId);
 
-    this.logger.info('[items] validate item name uniquiness.', { itemName, tenantId });
+    this.logger.info('[items] validate item name uniquiness.', {
+      itemName,
+      tenantId,
+    });
     const foundItems: [] = await Item.query().onBuild((builder: any) => {
       builder.where('name', itemName);
       if (notItemId) {
@@ -69,7 +79,10 @@ export default class ItemsService implements IItemsService {
       }
     });
     if (foundItems.length > 0) {
-      this.logger.info('[items] item name already exists.', { itemName, tenantId });
+      this.logger.info('[items] item name already exists.', {
+        itemName,
+        tenantId,
+      });
       throw new ServiceError(ERRORS.ITEM_NAME_EXISTS);
     }
   }
@@ -80,18 +93,33 @@ export default class ItemsService implements IItemsService {
    * @param {number} costAccountId
    * @return {Promise<void>}
    */
-  private async validateItemCostAccountExistance(tenantId: number, costAccountId: number): Promise<void> {
+  private async validateItemCostAccountExistance(
-    const { accountRepository, accountTypeRepository } = this.tenancy.repositories(tenantId);
+    tenantId: number,
+    costAccountId: number
+  ): Promise<void> {
+    const {
+      accountRepository,
+      accountTypeRepository,
+    } = this.tenancy.repositories(tenantId);
 
-    this.logger.info('[items] validate cost account existance.', { tenantId, costAccountId });
+    this.logger.info('[items] validate cost account existance.', {
+      tenantId,
+      costAccountId,
+    });
     const COGSType = await accountTypeRepository.getByKey('cost_of_goods_sold');
-    const foundAccount = await accountRepository.findOneById(costAccountId)
+    const foundAccount = await accountRepository.findOneById(costAccountId);
 
     if (!foundAccount) {
-      this.logger.info('[items] cost account not found.', { tenantId, costAccountId });
+      this.logger.info('[items] cost account not found.', {
+        tenantId,
+        costAccountId,
+      });
       throw new ServiceError(ERRORS.COST_ACCOUNT_NOT_FOUMD);
     } else if (foundAccount.accountTypeId !== COGSType.id) {
-      this.logger.info('[items] validate cost account not COGS type.', { tenantId, costAccountId });
+      this.logger.info('[items] validate cost account not COGS type.', {
+        tenantId,
+        costAccountId,
+      });
       throw new ServiceError(ERRORS.COST_ACCOUNT_NOT_COGS);
     }
   }
@@ -101,18 +129,33 @@ export default class ItemsService implements IItemsService {
    * @param {number} tenantId - Tenant id.
    * @param {number} sellAccountId - Sell account id.
    */
-  private async validateItemSellAccountExistance(tenantId: number, sellAccountId: number) {
+  private async validateItemSellAccountExistance(
-    const { accountRepository, accountTypeRepository } = this.tenancy.repositories(tenantId);
+    tenantId: number,
+    sellAccountId: number
+  ) {
+    const {
+      accountRepository,
+      accountTypeRepository,
+    } = this.tenancy.repositories(tenantId);
 
-    this.logger.info('[items] validate sell account existance.', { tenantId, sellAccountId });
+    this.logger.info('[items] validate sell account existance.', {
+      tenantId,
+      sellAccountId,
+    });
     const incomeType = await accountTypeRepository.getByKey('income');
     const foundAccount = await accountRepository.findOneById(sellAccountId);
 
     if (!foundAccount) {
-      this.logger.info('[items] sell account not found.', { tenantId, sellAccountId });
+      this.logger.info('[items] sell account not found.', {
-      throw new ServiceError(ERRORS.SELL_ACCOUNT_NOT_FOUND)
+        tenantId,
+        sellAccountId,
+      });
+      throw new ServiceError(ERRORS.SELL_ACCOUNT_NOT_FOUND);
     } else if (foundAccount.accountTypeId !== incomeType.id) {
-      this.logger.info('[items] sell account not income type.', { tenantId, sellAccountId });
+      this.logger.info('[items] sell account not income type.', {
+        tenantId,
+        sellAccountId,
+      });
       throw new ServiceError(ERRORS.SELL_ACCOUNT_NOT_INCOME);
     }
   }
@@ -122,18 +165,35 @@ export default class ItemsService implements IItemsService {
    * @param {number} tenantId
    * @param {number} inventoryAccountId
    */
-  private async validateItemInventoryAccountExistance(tenantId: number, inventoryAccountId: number) {
+  private async validateItemInventoryAccountExistance(
-    const { accountTypeRepository, accountRepository } = this.tenancy.repositories(tenantId);
+    tenantId: number,
+    inventoryAccountId: number
+  ) {
+    const {
+      accountTypeRepository,
+      accountRepository,
+    } = this.tenancy.repositories(tenantId);
 
-    this.logger.info('[items] validate inventory account existance.', { tenantId, inventoryAccountId });
+    this.logger.info('[items] validate inventory account existance.', {
+      tenantId,
+      inventoryAccountId,
+    });
     const otherAsset = await accountTypeRepository.getByKey('other_asset');
-    const foundAccount = await accountRepository.findOneById(inventoryAccountId);
+    const foundAccount = await accountRepository.findOneById(
+      inventoryAccountId
+    );
 
     if (!foundAccount) {
-      this.logger.info('[items] inventory account not found.', { tenantId, inventoryAccountId });
+      this.logger.info('[items] inventory account not found.', {
-      throw new ServiceError(ERRORS.INVENTORY_ACCOUNT_NOT_FOUND)
+        tenantId,
+        inventoryAccountId,
+      });
+      throw new ServiceError(ERRORS.INVENTORY_ACCOUNT_NOT_FOUND);
     } else if (otherAsset.id !== foundAccount.accountTypeId) {
-      this.logger.info('[items] inventory account not inventory type.', { tenantId, inventoryAccountId });
+      this.logger.info('[items] inventory account not inventory type.', {
+        tenantId,
+        inventoryAccountId,
+      });
       throw new ServiceError(ERRORS.INVENTORY_ACCOUNT_NOT_INVENTORY);
     }
   }
@@ -143,7 +203,10 @@ export default class ItemsService implements IItemsService {
    * @param {number} tenantId
    * @param {number} itemCategoryId
    */
-  private async validateItemCategoryExistance(tenantId: number, itemCategoryId: number) {  
+  private async validateItemCategoryExistance(
+    tenantId: number,
+    itemCategoryId: number
+  ) {
     const { ItemCategory } = this.tenancy.models(tenantId);
     const foundCategory = await ItemCategory.query().findById(itemCategoryId);
 
@@ -168,19 +231,31 @@ export default class ItemsService implements IItemsService {
       await this.validateItemCategoryExistance(tenantId, itemDTO.categoryId);
     }
     if (itemDTO.sellAccountId) {
-      await this.validateItemSellAccountExistance(tenantId, itemDTO.sellAccountId);
+      await this.validateItemSellAccountExistance(
+        tenantId,
+        itemDTO.sellAccountId
+      );
     }
     if (itemDTO.costAccountId) {
-      await this.validateItemCostAccountExistance(tenantId, itemDTO.costAccountId);
+      await this.validateItemCostAccountExistance(
+        tenantId,
+        itemDTO.costAccountId
+      );
     }
     if (itemDTO.inventoryAccountId) {
-      await this.validateItemInventoryAccountExistance(tenantId, itemDTO.inventoryAccountId);
+      await this.validateItemInventoryAccountExistance(
+        tenantId,
+        itemDTO.inventoryAccountId
+      );
     }
     const storedItem = await Item.query().insertAndFetch({
       ...itemDTO,
       active: defaultTo(itemDTO.active, 1),
     });
-    this.logger.info('[items] item inserted successfully.', { tenantId, itemDTO });
+    this.logger.info('[items] item inserted successfully.', {
+      tenantId,
+      itemDTO,
+    });
 
     return storedItem;
   }
@@ -197,21 +272,40 @@ export default class ItemsService implements IItemsService {
     // Validates the given item existance on the storage.
     const oldItem = await this.getItemOrThrowError(tenantId, itemId);
 
+    // Validate the item category existance on the storage,
     if (itemDTO.categoryId) {
       await this.validateItemCategoryExistance(tenantId, itemDTO.categoryId);
     }
+    // Validate the sell account existance on the storage.
     if (itemDTO.sellAccountId) {
-      await this.validateItemSellAccountExistance(tenantId, itemDTO.sellAccountId);
+      await this.validateItemSellAccountExistance(
+        tenantId,
+        itemDTO.sellAccountId
+      );
     }
+    // Validate the cost account existance on the storage.
     if (itemDTO.costAccountId) {
-      await this.validateItemCostAccountExistance(tenantId, itemDTO.costAccountId);
+      await this.validateItemCostAccountExistance(
+        tenantId,
+        itemDTO.costAccountId
+      );
     }
+    // Validate the inventory account existance onthe storage.
     if (itemDTO.inventoryAccountId) {
-      await this.validateItemInventoryAccountExistance(tenantId, itemDTO.inventoryAccountId);
+      await this.validateItemInventoryAccountExistance(
+        tenantId,
+        itemDTO.inventoryAccountId
+      );
     }
 
-    const newItem = await Item.query().patchAndFetchById(itemId, { ...itemDTO });
+    const newItem = await Item.query().patchAndFetchById(itemId, {
-    this.logger.info('[items] item edited successfully.', { tenantId, itemId, itemDTO });
+      ...itemDTO,
+    });
+    this.logger.info('[items] item edited successfully.', {
+      tenantId,
+      itemId,
+      itemDTO,
+    });
 
     return newItem;
   }
@@ -233,6 +327,46 @@ export default class ItemsService implements IItemsService {
     this.logger.info('[items] deleted successfully.', { tenantId, itemId });
   }
 
+  /**
+   * Activates the given item on the storage.
+   * @param {number} tenantId -
+   * @param {number} itemId -
+   * @return {Promise<void>}
+   */
+  public async activateItem(tenantId: number, itemId: number): Promise<void> {
+    const { Item } = this.tenancy.models(tenantId);
+
+    this.logger.info('[items] trying to activate the given item.', {
+      tenantId,
+      itemId,
+    });
+    const item = await this.getItemOrThrowError(tenantId, itemId);
+
+    await Item.query().findById(itemId).patch({ active: true });
+
+    this.logger.info('[items] activated successfully.', { tenantId, itemId });
+  }
+
+  /**
+   * Inactivates the given item on the storage.
+   * @param {number} tenantId
+   * @param {number} itemId
+   * @return {Promise<void>}
+   */
+  public async inactivateItem(tenantId: number, itemId: number): Promise<void> {
+    const { Item } = this.tenancy.models(tenantId);
+
+    this.logger.info('[items] trying to inactivate the given item.', {
+      tenantId,
+      itemId,
+    });
+    const item = await this.getItemOrThrowError(tenantId, itemId);
+
+    await Item.query().findById(itemId).patch({ active: false });
+
+    this.logger.info('[items] activated successfully.', { tenantId, itemId });
+  }
+
   /**
    * Retrieve the item details of the given id with associated details.
    * @param {number} tenantId
@@ -241,8 +375,19 @@ export default class ItemsService implements IItemsService {
   public async getItem(tenantId: number, itemId: number): Promise<IItem> {
     const { Item } = this.tenancy.models(tenantId);
 
-    const item = Item.query().findById(itemId)
+    this.logger.info('[items] trying to get the specific item.', {
-      .withGraphFetched('costAccount', 'sellAccount', 'inventoryAccount', 'category');
+      tenantId,
+      itemId,
+    });
+
+    const item = await Item.query()
+      .findById(itemId)
+      .withGraphFetched(
+        'costAccount',
+        'sellAccount',
+        'inventoryAccount',
+        'category'
+      );
 
     if (!item) {
       throw new ServiceError(ERRORS.NOT_FOUND);
@@ -273,12 +418,18 @@ export default class ItemsService implements IItemsService {
   public async bulkDeleteItems(tenantId: number, itemsIds: number[]) {
     const { Item } = this.tenancy.models(tenantId);
 
-    this.logger.info('[items] trying to delete items in bulk.', { tenantId, itemsIds });
+    this.logger.info('[items] trying to delete items in bulk.', {
+      tenantId,
+      itemsIds,
+    });
     await this.validateItemsIdsExists(tenantId, itemsIds);
     await this.validateHasNoInvoicesOrBills(tenantId, itemsIds);
 
     await Item.query().whereIn('id', itemsIds).delete();
-    this.logger.info('[items] deleted successfully in bulk.', { tenantId, itemsIds });
+    this.logger.info('[items] deleted successfully in bulk.', {
+      tenantId,
+      itemsIds,
+    });
   }
 
   /**
@@ -288,20 +439,27 @@ export default class ItemsService implements IItemsService {
    */
   public async itemsList(tenantId: number, itemsFilter: IItemsFilter) {
     const { Item } = this.tenancy.models(tenantId);
-    const dynamicFilter = await this.dynamicListService.dynamicList(tenantId, Item, itemsFilter);
+    const dynamicFilter = await this.dynamicListService.dynamicList(
-
+      tenantId,
-    const { results, pagination } = await Item.query().onBuild((builder) => {
+      Item,
-      builder.withGraphFetched('inventoryAccount');
+      itemsFilter
-      builder.withGraphFetched('sellAccount');
-      builder.withGraphFetched('costAccount');
-      builder.withGraphFetched('category');
-
-      dynamicFilter.buildQuery()(builder);
-    }).pagination(
-      itemsFilter.page - 1,
-      itemsFilter.pageSize,
     );
-    return { items: results, pagination, filterMeta: dynamicFilter.getResponseMeta() };
+
+    const { results, pagination } = await Item.query()
+      .onBuild((builder) => {
+        builder.withGraphFetched('inventoryAccount');
+        builder.withGraphFetched('sellAccount');
+        builder.withGraphFetched('costAccount');
+        builder.withGraphFetched('category');
+
+        dynamicFilter.buildQuery()(builder);
+      })
+      .pagination(itemsFilter.page - 1, itemsFilter.pageSize);
+    return {
+      items: results,
+      pagination,
+      filterMeta: dynamicFilter.getResponseMeta(),
+    };
   }
 
   /**
@@ -310,7 +468,10 @@ export default class ItemsService implements IItemsService {
    * @param  {number|number[]} itemId - Item id.
    * @throws {ServiceError}
    */
-  private async validateHasNoInvoicesOrBills(tenantId: number, itemId: number[]|number) {
+  private async validateHasNoInvoicesOrBills(
+    tenantId: number,
+    itemId: number[] | number
+  ) {
     const { ItemEntry } = this.tenancy.models(tenantId);
 
     const ids = Array.isArray(itemId) ? itemId : [itemId];
@@ -319,9 +480,10 @@ export default class ItemsService implements IItemsService {
       .whereIn('reference_type', ['SaleInvoice', 'Bill']);
 
     if (foundItemEntries.length > 0) {
-      throw new ServiceError(ids.length > 1 ?
+      throw new ServiceError(
-        ERRORS.ITEMS_HAVE_ASSOCIATED_TRANSACTIONS :
+        ids.length > 1
-        ERRORS.ITEM_HAS_ASSOCIATED_TRANSACTINS
+          ? ERRORS.ITEMS_HAVE_ASSOCIATED_TRANSACTIONS
+          : ERRORS.ITEM_HAS_ASSOCIATED_TRANSACTINS
       );
     }
   }