How to use

between

function

in

sequelize

async index(req, res) {
  const checkUserProvider = await User.findOne({
   where: { id: req.userId, provider: true },
  });

  if (!checkUserProvider) {
   return req.status(401).json({ error: 'User is not a provider' });
  }

  const { date } = req.query;
  const parseDate = parseISO(date);

  const appointments = await Appointment.findAll({
   where: {
    provider_id: req.userId,
    canceled_at: null,
    date: {
     [Op.between]: [startOfDay(parseDate), endOfDay(parseDate)],
    },
   },
   include: [{ model: User, as: 'user', attributes: ['name'] }],
   order: ['date'],
  });

  return res.json({ appointments });
 }

async index (req, res) {
  const appointments = await Appointment.findAll({
   include: [{ model: User, as: 'user' }],
   where: {
    provider_id: req.session.user.id,
    date: {
     [Op.between]: [
      moment()
       .startOf('day')
       .format(),
      moment()
       .endOf('day')
       .format()
     ]
    }
   }
  });

  // If there is no appointment at the moment, give the user a message
  if (appointments.length === 0) {
   req.flash('error', 'There is no schedule for today up to this moment.');
   return res.redirect('/app/dashboard');
  }

  return res.render('schedule/index', { appointments });
 }

where: {
 date: {
  [Op.between]: [startOfDay(parsedDate), endOfDay(parsedDate)],
 },
},

describe('buildInRangeQuery Tests', () => {
    test('Should return a range query', () => {
      const expectedResult = { name: 'foo', value: { [Op.between]: [1, 10] } };
      let observedResult = sqlQB.buildInRangeQuery({
        field: 'foo',
        lowerBound: 1,
        upperBound: 10,
      });
      expect(observedResult).toEqual(expectedResult);
    });
    test('Should return an exclusive range query if given an invert flag', () => {
      const expectedResult = {
        name: 'foo',
        value: { [Op.notBetween]: [1, 10] },
      };
      let observedResult = sqlQB.buildInRangeQuery({
        field: 'foo',
        lowerBound: 1,
        upperBound: 10,
        invert: true,
      });
      expect(observedResult).toEqual(expectedResult);
    });
  });

 student_id,
 createdAt: {
  [Op.between]: [limitDay, today],
 },
},

},
create_date: {
  [Op.between]: [
    new Date(TimeNow.showMonthFirstDay()),
    new Date(TimeNow.showMonthLastDay())

 where: {
  provider_id: req.params.provider,
  date: { [Op.between]: [date.startOf('day').format(), date.endOf('day').format()] },
 },
});

deliveryman_id,
start_date: {
 [Op.between]: [startOfDay(initialDate), endOfDay(initialDate)]

 canceled_at: null,
 date: {
  [Op.between]: [startOfDay(searchDate), endOfDay(searchDate)],
 },
},

 canceled_at: null,
 date: {
  [Op.between]: [startOfDay(parsedDate), endOfDay(parsedDate)],
 },
},

describe('buildInRangeQuery Tests', () => {
    test('Should return a range query', () => {
      const expectedResult = { name: 'foo', value: { [Op.between]: [1, 10] } };
      let observedResult = sqlQB.buildInRangeQuery({
        field: 'foo',
        lowerBound: 1,
        upperBound: 10,
      });
      expect(observedResult).toEqual(expectedResult);
    });
    test('Should return an exclusive range query if given an invert flag', () => {
      const expectedResult = {
        name: 'foo',
        value: { [Op.notBetween]: [1, 10] },
      };
      let observedResult = sqlQB.buildInRangeQuery({
        field: 'foo',
        lowerBound: 1,
        upperBound: 10,
        invert: true,
      });
      expect(observedResult).toEqual(expectedResult);
    });
  });

 canceled_at: null,
 date: {
  [Op.between]: [startOfDay(parsedDate), endOfDay(parsedDate)],
 },
},

 canceled_at: null,
 date: {
  [Op.between]: [startOfDay(parsedDate), endOfDay(parsedDate)],
 },
},

 canceled_at: null,
 date: {
  [Op.between]: [startOfDay(parsedDate), endOfDay(parsedDate)],
 },
},

 date: {
  [Op.between]: [startOfDay(parsedDate), endOfDay(parsedDate)],
 },
},