cluedin-widget/wmsBackend/index.js

This project contains all the pages needed for browsing entities and searching them. The aim is to replace the CluedIn.Webapp project with this one when all the pages ( including the Admin page ) will be ported to REACT.

var lodash = require('lodash');
var allDefaults = void 0;
var allLayoutDefaults = void 0;
var entityConfig = {};
var layoutConfig = {};
var widgetConfigurationModel = require('./models/WidgetConfiguration');
var layoutModel = require('./models/Layout');
var UserProfileModel = require('./models/UserProfile');

var getAllDefault = function (cb) {

  if (allDefaults) {
    return cb(null, allDefaults);
  }

  widgetConfigurationModel.find({ isDefault: true }).exec(function (err, defaults) {
    allDefaults = defaults;
    return cb(null, defaults);
  });
};

var getByClientId = function (clientId, cb) {
  widgetConfigurationModel.find({ owner: clientId }).exec(function (err, widgetsPerClientId) {
    if (err) {
      return cb(err);
    }

    return cb(null, widgetsPerClientId);
  });
};

var getAllDefaultLayout = function (cb) {

  if (allLayoutDefaults) {
    return cb(null, allLayoutDefaults)
  }

  layoutModel.find({ isDefault: true }).exec(function (err, defaults) {
    allLayoutDefaults = defaults;
    return cb(null, defaults);
  });
};

var getLayoutByClientId = function (clientId, cb) {
  layoutModel.find({ owner: clientId }).exec(function (err, layoutsPerClientId) {
    return cb(null, layoutsPerClientId);
  });
};

var getLayoutConfiguration = function (clientId, cb) {
  var result = [];

  if (layoutConfig[clientId]) {
    return cb(null, layoutConfig[clientId]);
  }

  getAllDefaultLayout(function (err, defaults) {
    getLayoutByClientId(clientId, function (err, layouts) {
      defaults.forEach(function (defaultLayout) {
        var customizeLayout = lodash.find(layouts, function (l) {
          return defaultLayout.code === l.code;
        });

        if (customizeLayout) {
          result.push(customizeLayout);
        } else {
          result.push(defaultLayout);
        }
      });

      layoutConfig[clientId] = result;

      return cb(null, result);
    });
  });
};

var getWidgetConfiguration = function (clientId, cb) {
  var result = [];

  if (entityConfig[clientId]) {
    return cb(null, entityConfig[clientId]);
  }

  getAllDefault(function (err, defaults) {
    getByClientId(clientId, function (err, widgets) {
      defaults.forEach(function (defaultWidget) {
        var customizedWidget = lodash.find(widgets, function (w) {
          return defaultWidget.entityType === w.entityType;
        });

        if (customizedWidget) {
          result.push(customizedWidget);
        } else {
          result.push(defaultWidget);
        }
      });

      entityConfig[clientId] = result;

      return cb(null, result);
    });
  });
};

const getConfiguration = function (clientId, done) {
  getWidgetConfiguration(clientId, function (err, all) {
    if (err) {
      return done(err);
    }
    getLayoutConfiguration(clientId, function (err, allLayouts) {
      if (err) {
        return done(err);
      }

      return done(null, {
        widgets: all,
        layouts: allLayouts
      });
    });
  });
};

const getUserProfile = function (userId, done) {
  UserProfileModel.findOne({ userId: userId }).exec(done);
};

const mergeCluedInWithOrgWidgets = function (base, override) {
  let result = override;

  base.filter(function (w) {
    var isPresent = override.find(function (wFromOrg) {
      return wFromOrg.name.toLowerCase() === w.name.toLowerCase();
    });

    if (!isPresent) {
      result.push(w);
    }
  });

  return result;
};

var removeUserProfile = function (userId, done) {
  UserProfileModel.remove({ userId: userId }, done);
};

var saveUserProfile = function (userProfile, done) {
  UserProfileModel.findOne({ userId: userProfile.userId }).exec(function (err, userProfileFound) {
    if (err) {
      return done(err);
    }

    if (!userProfileFound) {
      var newUserProfile = new UserProfileModel(userProfile);
      newUserProfile.save(function (errFromSave) {
        done(errFromSave);
      });
    } else {
      userProfileFound.widgets = userProfile.widgets;
      userProfileFound.isOnBoardingFinished = userProfile.isOnBoardingFinished;
      userProfileFound.widgetState = userProfile.widgetState;
      userProfileFound.widgetConfiguration = userProfile.widgetConfiguration;
      userProfileFound.markModified('widgetConfiguration');

      userProfileFound.save(done);
    }
  });
};

var manageWidget = function (isDeleted) {
  return function (clientId, userId, widgetToAdd, done) {
    getConfiguration(clientId, function (err, widgetConfiguration) {
      if (err) {
        done(err);
      }
      getUserProfile(userId, function (errUserProfile, userProfile) {
        let userProfileToSave = userProfile;

        if (errUserProfile) {
          done(errUserProfile);
        }

        if (!userProfile) {
          userProfileToSave = new UserProfileModel({
            userId: userId,
          });
        }

        let widgetConfigForEntityType = widgetConfiguration.widgets.find(function (w) {
          return w.entityType.toLowerCase() === widgetToAdd.entityType.toLowerCase();
        });

        if (!widgetConfigForEntityType) {
          done('invalid entity type');
        }

        let hasWidgetEntityType = lodash.find(userProfileToSave.widgetConfiguration || [], function (configPerEntity) {
          return configPerEntity.entityType.toLowerCase() === widgetToAdd.entityType.toLowerCase();
        });

        if (!hasWidgetEntityType) {
          userProfileToSave.widgetConfiguration.push({
            entityType: widgetToAdd.entityType,
            widgets: [{
              name: widgetToAdd.name,
              place: widgetToAdd.place,
              isAdmin: widgetToAdd.isAdmin,
              isDeleted: isDeleted,
              parameters: JSON.stringify(widgetToAdd.values),
            }],
          });

        } else {
          /*let newEntityType = lodash.filter(hasWidgetEntityType.widgets, function (w) {
            return w.name.toLowerCase() !== widgetToAdd.name.toLowerCase();
          });*/

          //hasWidgetEntityType.widgets = newEntityType || [];
          hasWidgetEntityType.widgets.push({
            name: widgetToAdd.name,
            place: widgetToAdd.place,
            isAdmin: widgetToAdd.isAdmin,
            isDeleted: isDeleted,
            parameters: JSON.stringify(widgetToAdd.values),
          });

          userProfileToSave.widgetConfiguration = hasWidgetEntityType;
        }

        saveUserProfile(userProfileToSave, function (errFromSave) {
          done(errFromSave, userProfileToSave);
        });
      });
    });
  };
};

module.exports = {
  getConfiguration: getConfiguration,
  getUserProfile: getUserProfile,
  removeWidgetToUserProfile: manageWidget(true),
  addWidgetToUserProfile: manageWidget(),
  saveUserProfile: saveUserProfile,
  removeUserProfile: removeUserProfile,
};