How to use

or

function

in

sequelize

search(channel) {
    return Configs.findAll({
      attributes: ['result_data', 'task_start_time', 'task_end_time', 'state', 'proption'],
      where: {
        channel,
        [Op.or]: [{ status: 1 }, { status: 2 }]
      }
    });
  }

userSearchQuery(searchName, field, value, w) {
   return w[Op.or] = {
    email: {
     [Op.eq]: value
    },
    displayName: {
     [Op.like]: value+'%'
    },
    username: {
     [Op.eq]: value
    }
   };
  }

db.Video.findAll({
   where: {
    yt_video_key: { [Op.not]: null },
    [Op.or]: [
     { status: [STATUSES.LIVE, STATUSES.UPCOMING] },
     { status: STATUSES.MISSING, live_schedule: { [Op.gt]: utcDate.clone().subtract(3, 'hour') } },
    ],
   },
   order: [
    ['status', 'ASC'],
    ['updated_at', 'ASC'],
   ],
   limit: 50,
  }).catch((err) => {
   // Catch and log db error
   log.error('videoStatusAPI() Unable to fetch videos for tracking', { error: err.toString() });
   // Return empty list, so the succeeding process for upcoming videos wil continue
   return [];
  })

describe('buildOrQuery Tests', () => {
    test('Should return an OR of given queries', () => {
      const expectedResult = { [Op.or]: [{ foo: 'bar' }, { bar: 'foo' }] };
      let observedResult = sqlQB.buildOrQuery({
        queries: [{ foo: 'bar' }, { bar: 'foo' }],
      });
      expect(observedResult).toEqual(expectedResult);
    });
    test('Should return a NOR of given queries if invert option is true', () => {
      const expectedResult = {
        [Op.not]: { [Op.or]: [{ foo: 'bar' }, { bar: 'foo' }] },
      };
      let observedResult = sqlQB.buildOrQuery({
        queries: [{ foo: 'bar' }, { bar: 'foo' }],
        invert: true,
      });
      expect(observedResult).toEqual(expectedResult);
    });
  });

 coinName: 'bitcoin',
 address: {
  [Op.or]: addrsFromTx,
 },
},

User.create({
  name: req.body.name,
  email: req.body.email,
  state: req.body.state,
  password: bcrypt.hashSync(req.body.password, 8)
 })
  .then(user => {
   if (req.body.roles) {
    Role.findAll({
     where: {
      name: {
       [Op.or]: req.body.roles
      }
     }
    }).then(roles => {
     user.setRoles([1]).then(() => {
      res.send({ message: "User was registered successfully!" });
     });
    });
   }
  })
  .catch(err => {
   res.status(500).send({ message: err.message });
  });

/**
 * Takes in a list of queries and wraps them in an $or block
 */
const buildOrQuery = function({ queries, invert = false }) {
  if (invert) {
    return { [Op.not]: { [Op.or]: queries } };
  } else {
    return { [Op.or]: queries };
  }
}

// Save User in the database
 User.create(user).then(data => {
   if (req.body.roles) {
    Role.findAll({
     where: {
      name: {
       [Op.or]: req.body.roles
      }
     }
    }).then(roles => {
     data.setRoles(roles).then(() => {
      res.send({ message: "User was registered successfully!" });
     });
    });
   } else {
    // user role = 1
    data.setRoles([1]).then(() => {
     res.send({ message: "User was registered successfully!" });
    });
   }
  res.send(data);
 }).catch(err => {
  res.status(500).send({
   message: err.message || "Some error occurred while creating the user."
  });
 });

[Op.and]: [
  [Op.or]: [

is_public: true,
status: {
  [Op.or]: [constant_1.statusList.reviewSuccess, constant_1.statusList.freeReview]
},
create_date: {

// Save User to Database
 User.create({
  username: req.body.username,
  email: req.body.email,
  password: bcrypt.hashSync(req.body.password, 8)
 })
  .then(user => {
   if (req.body.roles) {
    Role.findAll({
     where: {
      name: {
       [Op.or]: req.body.roles
      }
     }
    }).then(roles => {
     user.setRoles(roles).then(() => {
      res.send({ message: "User registered successfully!" });
     });
    });
   } else {
    // user role = 1
    user.setRoles([1]).then(() => {
     res.send({ message: "User registered successfully!" });
    });
   }
  })
  .catch(err => {
   res.status(500).send({ message: err.message });
  });

const searchUsers = id => {
 try {
  return User.findAll({
   where: {
    [Op.or]: [
     { username: { [Op.like]: `%${id}%` } },
     { name: { [Op.like]: `%${id}%` } },
    ],
   },
   limit: 10,
  });
 } catch (err) {
  throw new Error(errorName.USERS_SEARCH_ERROR);
 }
}

/**
 * Takes in a list of queries and wraps them in an $or block
 */
const buildOrQuery = function({ queries, invert = false }) {
  if (invert) {
    return { [Op.not]: { [Op.or]: queries } };
  } else {
    return { [Op.or]: queries };
  }
}

describe('buildOrQuery Tests', () => {
    test('Should return an OR of given queries', () => {
      const expectedResult = { [Op.or]: [{ foo: 'bar' }, { bar: 'foo' }] };
      let observedResult = sqlQB.buildOrQuery({
        queries: [{ foo: 'bar' }, { bar: 'foo' }],
      });
      expect(observedResult).toEqual(expectedResult);
    });
    test('Should return a NOR of given queries if invert option is true', () => {
      const expectedResult = {
        [Op.not]: { [Op.or]: [{ foo: 'bar' }, { bar: 'foo' }] },
      };
      let observedResult = sqlQB.buildOrQuery({
        queries: [{ foo: 'bar' }, { bar: 'foo' }],
        invert: true,
      });
      expect(observedResult).toEqual(expectedResult);
    });
  });

 coinName: 'bitcoin',
 address: {
  [Op.or]: addrsFromTx,
 },
},