@knovator/pagecreator-node 1.2.0 → 1.2.2

package/src/controllers/WidgetController.ts

@@ -1,420 +0,0 @@
-import { Models, Types } from 'mongoose';
-import {
-  create,
-  remove,
-  update,
-  list,
-  bulkInsert,
-  deleteAll,
-  getOne,
-  checkUnique,
-} from '../services/dbService';
-import { VALIDATION } from '../constants';
-import {
-  successResponse,
-  createdDocumentResponse,
-} from './../utils/responseHandlers';
-
-import { commonExcludedFields, defaults } from '../utils/defaults';
-import { formatCollectionItems, getCollectionModal } from '../utils/helper';
-import {
-  CollectionItem,
-  IRequest,
-  IResponse,
-  WidgetTypes,
-  TypesType,
-  ItemsType,
-} from '../types';
-import {
-  updateRedisWidget,
-  updateWidgetPagesData,
-} from '../services/dataService';
-
-const catchAsync = (fn: any) => {
-  return defaults.catchAsync(fn, 'Widget');
-};
-
-const getModals = (req: IRequest) => defaults.getModals(req);
-
-const deleteItems = async (widgetId: string, models: Models) => {
-  const { Item } = models;
-  await deleteAll(Item, { widgetId: new Types.ObjectId(widgetId) });
-};
-const createItems = async (
-  itemsData: any[],
-  widgetId: string,
-  models: Models
-) => {
-  const { Item, SrcSet } = models;
-  itemsData = itemsData.map((item: any) => ({
-    ...item,
-    _id: new Types.ObjectId(),
-    widgetId,
-  }));
-  const srcSetItems = itemsData.reduce((acc: any[], item: any) => {
-    if (Array.isArray(item.srcset)) {
-      acc.push(
-        ...item.srcset.map((srcSetItem: any) => ({
-          ...srcSetItem,
-          itemId: item._id,
-        }))
-      );
-      delete item.srcset;
-    }
-    return acc;
-  }, []);
-  await bulkInsert(Item, itemsData);
-  await bulkInsert(SrcSet, srcSetItems);
-};
-
-export const createWidget = catchAsync(
-  async (req: IRequest, res: IResponse) => {
-    const models = getModals(req);
-    const data = req.body;
-    let items = [];
-   
-    await checkUnique({
-      Modal: models['Widget'],
-      uniqueField: 'code',
-      value: data.code,
-      errorMessage: VALIDATION.WIDGET_EXISTS
-    });
-
-    if ('items' in data) {
-      items = JSON.parse(JSON.stringify(data.items));
-      delete data.items;
-    }
-    const widget = await create(models['Widget'], data);
-    if (items.length > 0) {
-      await createItems(items, widget._id, models);
-    }
-    res.message = req?.i18n?.t('widget.create');
-    return createdDocumentResponse(widget, res);
-  }
-);
-
-export const updateWidget = catchAsync(
-  async (req: IRequest, res: IResponse) => {
-    const models = getModals(req);
-    const data = req.body;
-    const _id = req.params['id'];
-    let items = [];
-    if ('items' in data) {
-      items = JSON.parse(JSON.stringify(data.items));
-      delete data.items;
-    }
-    const updatedWidget = await update(models['Widget'], { _id }, data);
-    if (items.length > 0 && updatedWidget) {
-      await deleteItems(_id, models);
-      await createItems(items, updatedWidget._id, models);
-    }
-    if (updatedWidget) {
-      updateRedisWidget(updatedWidget.code, models);
-      updateWidgetPagesData([updatedWidget.id], models);
-    }
-    res.message = req?.i18n?.t('widget.update');
-    return successResponse(updatedWidget, res);
-  }
-);
-
-export const deleteWidget = catchAsync(
-  async (req: IRequest, res: IResponse) => {
-    const models = getModals(req);
-    await deleteItems(req.params['id'], models);
-    const _id = new Types.ObjectId(req.params['id']);
-    const deletedWidget = await remove(models['Widget'], { _id });
-    if (deletedWidget) {
-      updateRedisWidget(deletedWidget.code, models);
-      updateWidgetPagesData([deletedWidget.id], models);
-    }
-    res.message = req?.i18n?.t('widget.delete');
-    return successResponse(deletedWidget, res);
-  }
-);
-
-export const getWidgets = catchAsync(async (req: IRequest, res: IResponse) => {
-  const { Widget } = getModals(req);
-  const search = req.body.search || '';
-  const { collectionItems } = req.body;
-  const { page, limit, sort } = req.body.options;
-  const all =
-    (typeof req.body.all !== 'undefined' && req.body.all === true) || false;
-  const isActive =
-    typeof req.body.isActive !== 'undefined'
-      ? req.body.isActive || false
-      : null;
-  const customOptions = {
-    pagination: !all,
-    sort,
-    select: 'name code isActive canDel',
-    ...(page && limit ? { page, limit } : {}),
-  };
-  const orOptions: any = [];
-  if (search) {
-    orOptions.push({ name: { $regex: search, $options: 'i' } });
-    orOptions.push({ code: { $regex: search, $options: 'i' } });
-  } else {
-    orOptions.push({});
-  }
-  if (Array.isArray(collectionItems) && collectionItems.length) {
-    orOptions.push({ _id: { $in: collectionItems } });
-  }
-  const query = {
-    isDeleted: false,
-    isActive: { $in: isActive === null ? [true, false] : [isActive] },
-    $or: orOptions,
-  };
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  const notifications = await list(Widget, query, customOptions);
-  res.message = req?.i18n?.t('widget.getAll');
-  return successResponse(notifications, res);
-});
-
-export const getSingleWidget = catchAsync(
-  async (req: IRequest, res: IResponse) => {
-    const { Widget, Item } = getModals(req);
-    const _id = req.params['id'];
-    const widget = await (
-      await getOne(Widget, { _id, isDeleted: true })
-    ).toJSON();
-    widget['items'] = await Item.aggregate([
-      {
-        $match: {
-          widgetId: new Types.ObjectId(_id),
-          isDeleted: false,
-        },
-      },
-      {
-        $project: {
-          ...commonExcludedFields,
-        },
-      },
-      ...(defaults.languages && defaults.languages?.length > 0
-        ? defaults.languages.reduce((arr: any[], lng) => {
-            arr.push(
-              {
-                $lookup: {
-                  from: 'file',
-                  let: { imgsId: { $toObjectId: `$imgs.${lng.code}` } },
-                  as: `imgs.${lng.code}`,
-                  pipeline: [
-                    {
-                      $match: {
-                        $expr: {
-                          $eq: ['$_id', '$$imgsId'],
-                        },
-                      },
-                    },
-                    {
-                      $project: {
-                        ...commonExcludedFields,
-                        width: 0,
-                        module: 0,
-                        height: 0,
-                      },
-                    },
-                  ],
-                },
-              },
-              {
-                $unwind: {
-                  path: `$imgs.${lng.code}`,
-                  preserveNullAndEmptyArrays: true,
-                },
-              }
-            );
-            return arr;
-          }, [])
-        : [
-            {
-              $lookup: {
-                from: 'file',
-                let: { imgId: '$img' },
-                as: 'img',
-                pipeline: [
-                  {
-                    $match: {
-                      $expr: {
-                        $eq: ['$_id', '$$imgId'],
-                      },
-                    },
-                  },
-                  {
-                    $project: {
-                      ...commonExcludedFields,
-                      width: 0,
-                      module: 0,
-                      height: 0,
-                    },
-                  },
-                ],
-              },
-            },
-            {
-              $unwind: {
-                path: '$img',
-                preserveNullAndEmptyArrays: true,
-              },
-            },
-          ]),
-      {
-        $lookup: {
-          from: 'srcsets',
-          let: { item: '$_id' },
-          as: 'srcset',
-          pipeline: [
-            {
-              $match: {
-                $expr: {
-                  $eq: ['$itemId', '$$item'],
-                },
-              },
-            },
-            {
-              $project: {
-                ...commonExcludedFields,
-                _id: 0,
-                itemId: 0,
-              },
-            },
-          ],
-        },
-      },
-    ]);
-    res.message = req?.i18n?.t('widget.getOne');
-    return successResponse(widget, res);
-  }
-);
-
-export const partialUpdateWidget = catchAsync(
-  async (req: IRequest, res: IResponse) => {
-    const models = getModals(req);
-    const data = req.body;
-    const _id = req.params['id'];
-    const updatedWidget = await update(models['Widget'], { _id }, data);
-    if (updatedWidget) {
-      updateRedisWidget(updatedWidget.code, models);
-      updateWidgetPagesData([updatedWidget.id], models);
-    }
-    res.message = req?.i18n?.t('widget.partialUpdate');
-    return successResponse(updatedWidget, res);
-  }
-);
-
-export const getItemsTypes = catchAsync(
-  async (req: IRequest, res: IResponse) => {
-    const itemsTypes: TypesType[] = [
-      {
-        value: Object.keys(ItemsType)[0],
-        label: Object.values(ItemsType)[0],
-      },
-    ];
-    defaults.collections.forEach((item: CollectionItem) => {
-      itemsTypes.push({
-        value: item.collectionName,
-        label: item.title,
-      });
-    });
-    res.message = req?.i18n?.t('widget.getItemsTypes');
-    return successResponse(itemsTypes, res);
-  }
-);
-
-export const getWidgetTypes = catchAsync(
-  async (req: IRequest, res: IResponse) => {
-    const widgetTypes: any[] = Object.entries(WidgetTypes).map((e) => ({
-      label: e[1],
-      value: e[0],
-    }));
-    if (
-      Array.isArray(defaults.customWidgetTypes) &&
-      defaults.customWidgetTypes.length > 0
-    ) {
-      widgetTypes.push(...defaults.customWidgetTypes);
-    }
-    res.message = req?.i18n?.t('widget.getWidgetTypes');
-    return successResponse(widgetTypes, res);
-  }
-);
-
-export const getCollectionData = catchAsync(async (req: IRequest, res: IResponse) => {
-  const models = getModals(req);
-  const { search, collectionName, collectionItems } = req.body;
-  const collectionItem: CollectionItem | undefined = defaults.collections.find(
-    (collection) => collection.collectionName === collectionName
-  );
-  if (!collectionItem) {
-    throw new Error(`No collection is specified with ${collectionName}`);
-  }
-  let limit = collectionItem.searchLimit || 10;
-  if (Array.isArray(collectionItems))
-    limit = Math.max(collectionItems.length, limit);
-  // setting up mongoose model
-  const TempModel = getCollectionModal(collectionName, models);
-  // fetching data
-  let query: any = collectionItem.filters || {};
-  const orOptions: any = [];
-  let addFieldOptions: any = {};
-  if (
-    search &&
-    Array.isArray(collectionItem.searchColumns) &&
-    collectionItem.searchColumns.length
-  ) {
-    collectionItem.searchColumns.forEach((column) =>
-      orOptions.push({
-        [column]: {
-          $regex: search,
-          $options: 'i',
-        },
-      })
-    );
-  } else {
-    orOptions.push({});
-  }
-  if (Array.isArray(collectionItems) && collectionItems.length) {
-    addFieldOptions = {
-      __order: {
-        $indexOfArray: [
-          collectionItems,
-          {
-            $toString: '$_id',
-          },
-        ],
-      },
-    };
-    orOptions.push({ _id: { $in: formatCollectionItems(collectionItems) } });
-  }
-  if (orOptions.length > 0) {
-    query = {
-      ...query,
-      $or: orOptions,
-    };
-  }
-  const collectionData = await TempModel.aggregate([
-    ...(Array.isArray(collectionItem.aggregations)
-      ? collectionItem.aggregations
-      : []),
-    {
-      $match: query,
-    },
-    { $addFields: addFieldOptions },
-    {
-      $sort: {
-        __order: -1,
-      },
-    },
-    {
-      $limit: limit,
-    },
-  ]);
-  res.message = req?.i18n?.t('widget.getCollectionData');
-  return successResponse({ docs: collectionData }, res);
-});
-
-export const getLanguages = catchAsync(async (req: any, res: any) => {
-  return successResponse(
-    Array.isArray(defaults.languages) ? defaults.languages : [],
-    res
-  );
-});

package/src/index.ts

@@ -1,59 +0,0 @@
-import { defaults } from './utils/defaults';
-import WidgetRoutes from './routes/WidgetRoute';
-import PageRoutes from './routes/PageRoute';
-import UserRoutes from './routes/UserRoute';
-import {
-  Widget,
-  Item,
-  Page,
-  Tab,
-  SrcSet,
-  WidgetSchema,
-  ItemSchema,
-  PageSchema,
-  SrcSetSchema,
-  TabSchema,
-} from './models';
-import { IConfig } from './types';
-import { handleUpdateData, handleResetData } from './services/dataService';
-
-function setConfig(config: Partial<IConfig>) {
-  if (config.logger) {
-    defaults.logger = config.logger;
-  }
-  if (typeof config.catchAsync === 'function')
-    defaults.catchAsync = config.catchAsync;
-  if (typeof config.getModals === 'function')
-    defaults.getModals = config.getModals;
-  if (Array.isArray(config.collections)) {
-    defaults.collections = config.collections;
-  }
-  if (Array.isArray(config.customWidgetTypes)) {
-    defaults.customWidgetTypes = config.customWidgetTypes;
-  }
-  if (typeof config.redis === 'string' || typeof config.redis === 'object') {
-    defaults.redis = config.redis;
-  }
-  if (Array.isArray(config.languages) && config.languages.length > 0) {
-    defaults.languages = config.languages;
-  }
-}
-
-export {
-  WidgetRoutes,
-  PageRoutes,
-  UserRoutes,
-  Widget,
-  Item,
-  Page,
-  Tab,
-  SrcSet,
-  WidgetSchema,
-  ItemSchema,
-  PageSchema,
-  SrcSetSchema,
-  TabSchema,
-  setConfig,
-  handleResetData,
-  handleUpdateData,
-};

package/src/models/Item.ts

@@ -1,53 +0,0 @@
-import { Schema, Types, model } from 'mongoose';
-import mongoosePaginate from 'mongoose-paginate-v2';
-import { softDeletePlugin } from '../plugins/softDelete';
-import { IModel, IItemSchema, ItemTypes } from '../types';
-import { defaults } from '../utils/defaults';
-
-const titlesSchema =
-  defaults.languages?.reduce((acc: any, lang) => {
-    acc[lang.code] = { type: String, required: true };
-    return acc;
-  }, {}) || {};
-
-const imagesSchema =
-  defaults.languages?.reduce((acc: any, lang) => {
-    acc[lang.code] = { type: Schema.Types.ObjectId, ref: 'file' };
-    return acc;
-  }, {}) || {};
-
-const altTextsSchema =
-  defaults.languages?.reduce((acc: any, lang) => {
-    acc[lang.code] = { type: String };
-    return acc;
-  }, {}) || {};
-
-const ItemSchema = new Schema<IItemSchema>({
-  widgetId: {
-    type: Types.ObjectId,
-    ref: 'Widget',
-  },
-  title: String,
-  titles: titlesSchema,
-  subtitle: String,
-  subtitles: titlesSchema,
-  altText: String,
-  altTexts: altTextsSchema,
-  link: String,
-  sequence: Number,
-  img: { type: Schema.Types.ObjectId, ref: 'file' },
-  imgs: imagesSchema,
-  itemType: {
-    type: String,
-    enum: Object.values(ItemTypes),
-    default: ItemTypes.Web,
-    required: true,
-  },
-});
-
-ItemSchema.plugin(softDeletePlugin);
-ItemSchema.plugin(mongoosePaginate);
-
-const Item = model('Item', ItemSchema) as unknown as IModel<IItemSchema>;
-
-export { Item, ItemSchema };

package/src/models/Page.ts

@@ -1,22 +0,0 @@
-import { Schema, model, Types } from 'mongoose';
-import mongoosePaginate from 'mongoose-paginate-v2';
-import { softDeletePlugin } from '../plugins/softDelete';
-import { IModel, IPageSchema } from '../types';
-
-const PageSchema = new Schema<IPageSchema>({
-  name: String,
-  code: String,
-  slug: String,
-  canDel: {
-    type: Boolean,
-    default: true,
-  },
-  widgets: [{ type: Types.ObjectId, ref: 'Widget' }],
-});
-
-PageSchema.plugin(softDeletePlugin);
-PageSchema.plugin(mongoosePaginate);
-
-const Page = model('Page', PageSchema) as unknown as IModel<IPageSchema>;
-
-export { Page, PageSchema };

package/src/models/SrcSet.ts

@@ -1,16 +0,0 @@
-import { Schema, model, Types, Model } from 'mongoose';
-import { ISrcSetSchema } from '../types';
-
-const SrcSetSchema = new Schema<ISrcSetSchema>({
-  width: Number,
-  height: Number,
-  screenSize: Number,
-  itemId: {
-    type: Types.ObjectId,
-    ref: 'Item',
-  },
-});
-
-const SrcSet: Model<ISrcSetSchema> = model('SrcSet', SrcSetSchema);
-
-export { SrcSet, SrcSetSchema };

package/src/models/Tab.ts

@@ -1,28 +0,0 @@
-import { Schema, model, Types } from 'mongoose';
-import mongoosePaginate from 'mongoose-paginate-v2';
-import { softDeletePlugin } from '../plugins/softDelete';
-import { IModel, ITabSchema } from '../types';
-import { defaults } from '../utils/defaults';
-
-const namesSchema =
-  defaults.languages?.reduce((acc: any, lang) => {
-    acc[lang.code] = { type: String, required: true };
-    return acc;
-  }, {}) || {};
-
-const TabSchema = new Schema<ITabSchema>({
-  name: String,
-  names: namesSchema,
-  widgetId: {
-    type: Types.ObjectId,
-    ref: 'Widget',
-  },
-  collectionItems: [{ type: Types.ObjectId }],
-});
-
-TabSchema.plugin(softDeletePlugin);
-TabSchema.plugin(mongoosePaginate);
-
-const Tab = model('Tab', TabSchema) as unknown as IModel<ITabSchema>;
-
-export { Tab, TabSchema };

package/src/models/Widget.ts

@@ -1,65 +0,0 @@
-import { Schema, model, Types } from 'mongoose';
-import mongoosePaginate from 'mongoose-paginate-v2';
-import { softDeletePlugin } from '../plugins/softDelete';
-import { IModel, IWidgetSchema, WidgetTypes, ItemsType } from '../types';
-import { defaults } from '../utils/defaults';
-
-const languageTitlesSchema =
-  defaults.languages?.reduce((acc: any, lang) => {
-    acc[lang.code] = { type: String, required: true };
-    return acc;
-  }, {}) || {};
-
-const WidgetSchema = new Schema<IWidgetSchema>({
-  name: String,
-  code: String,
-  autoPlay: {
-    type: Boolean,
-    default: false,
-  },
-  isActive: {
-    type: Boolean,
-    default: true,
-  },
-  widgetTitle: String,
-  widgetTitles: languageTitlesSchema,
-  webPerRow: Number,
-  mobilePerRow: Number,
-  tabletPerRow: Number,
-  collectionName: String,
-  backgroundColor: String,
-  collectionItems: [{ type: Types.ObjectId, refPath: 'collectionName' }],
-  itemsType: {
-    type: String,
-    default: ItemsType.Image,
-    required: true,
-  },
-  widgetType: {
-    type: String,
-    default: WidgetTypes.FixedCard,
-    required: true,
-  },
-  tabs: [
-    {
-      name: String,
-      names: languageTitlesSchema,
-      collectionItems: [{ type: Types.ObjectId, refPath: 'collectionName' }],
-    },
-  ],
-  canDel: {
-    type: Boolean,
-    default: true,
-  },
-  textContent: {type: String},
-  htmlContent: {type: String}
-});
-
-WidgetSchema.plugin(softDeletePlugin);
-WidgetSchema.plugin(mongoosePaginate);
-
-const Widget = model(
-  'Widget',
-  WidgetSchema
-) as unknown as IModel<IWidgetSchema>;
-
-export { Widget, WidgetSchema };