mujz / pg-search-sequelize Goto Github PK

directorsRouter.get('/search',role_auth.isAdmin, (request, response) => {
  let query =  request.query ? request.query.q : 400;

  if(query === 400) {
    return response.json({
        status: query,
    })
  } else  {
    return models.DirectorMaterializedView.searchByText(query).catch(console.log);
  }
})

'use strict';

let SearchModel = require("pg-search-sequelize");

module.exports = (sequelize, DataTypes) => {
const user = sequelize.define('user', {
    name: {
      type: DataTypes.STRING
    },
    email: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true
    },
    password: {
      type: DataTypes.STRING,
      allowNull: false
    },
    role_id: {
      allowNull: false,
      type: DataTypes.INTEGER,
      references: {
        model: "role",
        key: "id"
      }
    },
    profile_pic: {
      type: DataTypes.STRING
    }
  });

  user.associate = (models) => {
    user.belongsTo(models.role, {
      foreignKey: 'role_id'
    })
    user.hasMany(models.director, {
      foreignKey: 'user_id',
      onDelete: 'CASCADE'
    })
    user.hasMany(models.teacher, {
      foreignKey: 'user_id',
      onDelete: 'CASCADE'
    })
    user.hasMany(models.student, {
      foreignKey: 'user_id',
      onDelete: 'CASCADE'
    })
  }

  user.hook("beforeCreate", "passwordHashing", (user, options) => {
    let hashedPassword = passwordHelper.hash(user.password)
    return user.password = hashedPassword
  })
  user.hook("afterCreate", "emailNotification", (user, options) => {
    // Asynchronous way to send an email without
    //   interrupting the flow of the system
    Mailer.sendPasswordWelcomeTemplate(user)
      .then(console.log)
      .catch(console.log)

    return user;
  })
  return user;
};

'use strict';

const models = require("../models");

let SearchModel = require("pg-search-sequelize");

module.exports = (sequelize, DataTypes) => {
  let DirectorMaterializedView = sequelize.define('DirectorMaterializedView', {
      id: {type: DataTypes.INTEGER, primaryKey: true, autoIncrement: true},
      name: DataTypes.STRING,
      email: DataTypes.TEXT,
      profile_pic: DataTypes.TEXT
  }, {
      tableName: 'director_materialized_view',
      timestamps: false,
      search: true,
      defaultScope: {
      attributes: {
        exclude: ['profile_pic', 'id']
        }
      },
      referenceModel: 'user' // The model for which we're defining the materialized view
  });

  return DirectorMaterializedView;
};

fs
  .readdirSync(__dirname)
  .filter(file =>
    (file.indexOf('.') !== 0) &&
    (file !== basename) &&
    (file.slice(-3) === '.js'))
  .forEach(file => {
    const model = sequelize.import(path.join(__dirname, file));
    models[model.name] = model;
  });

Object.keys(models).forEach(key => {
  let model = models[key];
  if ('associate' in model) model.associate(models);

  if ('referenceModel' in model.options) model.referenceModel = models[model.options.referenceModel];

  if ('search' in model.options) new SearchModel(model);

  if ('customHooks' in model.options && 'afterSave' in model.options.customHooks) {
    let callback = () => model.options.customHooks.afterSave(models);
    model.afterCreate(callback);
    model.afterBulkCreate(callback);
    model.afterDestroy(callback);
    model.afterBulkDestroy(callback);
    model.afterUpdate(callback);
    model.afterBulkUpdate(callback);
  }
});

models.sequelize = sequelize;
models.Sequelize = Sequelize;

module.exports = models;

'use strict';

const QueryInterface = require("pg-search-sequelize").QueryInterface;
const models = require("../models");
const referenceModel = models.user;

const materializedViewName = "director_materialized_view";

const attributes = {
   name: "B",
   email: "A"
}

const options = {
    primaryKeyField: "id",
    include: [
        {
            model: models.director,
            foreignKey: "user_id",
            targetKey: "id",
            associationType: "hasOne", 
            attributes: { 
              phone: "D"
            }
        }
    ]
}

module.exports = {
  up: queryInterface => new QueryInterface(queryInterface).createMaterializedView(materializedViewName, referenceModel, attributes, options),

  down: queryInterface => new QueryInterface(queryInterface).dropMaterializedView(materializedViewName)
};

await models.MaterializedModel.scope('active').search(query);

await models.MaterializedModel.scope({ method: ['visibleFor', session] }).search(query);