typeorm#Between TypeScript Examples

The following examples show how to use typeorm#Between. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example #1
Source File: paginate.ts    From nestjs-paginate with MIT License 6 votes vote down vote up 
OperatorSymbolToFunction = new Map<FilterOperator, (...args: any[]) => FindOperator<string>>([
    [FilterOperator.EQ, Equal],
    [FilterOperator.GT, MoreThan],
    [FilterOperator.GTE, MoreThanOrEqual],
    [FilterOperator.IN, In],
    [FilterOperator.NULL, IsNull],
    [FilterOperator.LT, LessThan],
    [FilterOperator.LTE, LessThanOrEqual],
    [FilterOperator.BTW, Between],
    [FilterOperator.NOT, Not],
])
Example #2
Source File: purge.ts    From fosscord-server with GNU Affero General Public License v3.0 5 votes vote down vote up 
/**
TODO: apply the delete bit by bit to prevent client and database stress
**/
router.post("/", route({ /*body: "PurgeSchema",*/ }), async (req: Request, res: Response) => {
	const { channel_id } = req.params;
	const channel = await Channel.findOneOrFail({ id: channel_id });
	
	if (!channel.guild_id) throw new HTTPError("Can't purge dm channels", 400);
	isTextChannel(channel.type);

	const rights = await getRights(req.user_id);
	if (!rights.has("MANAGE_MESSAGES")) {
		const permissions = await getPermission(req.user_id, channel.guild_id, channel_id);
		permissions.hasThrow("MANAGE_MESSAGES");
		permissions.hasThrow("MANAGE_CHANNELS");
	}
	
	const { before, after } = req.body as PurgeSchema;

	// TODO: send the deletion event bite-by-bite to prevent client stress

	var query: FindManyOptions<Message> & { where: { id?: any; }; } = {
		order: { id: "ASC" },
		// take: limit,
		where: {
		 channel_id,
		 id: Between(after, before), // the right way around
		 author_id: rights.has("SELF_DELETE_MESSAGES") ? undefined : Not(req.user_id)
		 // if you lack the right of self-deletion, you can't delete your own messages, even in purges
		 },
		relations: ["author", "webhook", "application", "mentions", "mention_roles", "mention_channels", "sticker_items", "attachments"]
	};
	

	const messages = await Message.find(query);
	const endpoint = Config.get().cdn.endpointPublic;
			
	if (messages.length == 0) { 
		res.sendStatus(304);
		return;
	}

	await Message.delete(messages.map((x) => ({ id: x })));
	
	await emitEvent({
		event: "MESSAGE_DELETE_BULK",
		channel_id,
		data: { ids: messages.map(x => x.id), channel_id, guild_id: channel.guild_id }
	} as MessageDeleteBulkEvent);

	res.sendStatus(204);
});
Example #3
Source File: course.service.ts    From office-hours with GNU General Public License v3.0 5 votes vote down vote up 
async getTACheckInCheckOutTimes(
    courseId: number,
    startDate: string,
    endDate: string,
  ): Promise<TACheckinTimesResponse> {
    const startDateAsDate = new Date(startDate);
    const endDateAsDate = new Date(endDate);
    if (startDateAsDate.getUTCDate() === endDateAsDate.getUTCDate()) {
      endDateAsDate.setUTCDate(endDateAsDate.getUTCDate() + 1);
    }

    const taEvents = await EventModel.find({
      where: {
        eventType: In([
          EventType.TA_CHECKED_IN,
          EventType.TA_CHECKED_OUT,
          EventType.TA_CHECKED_OUT_FORCED,
        ]),
        time: Between(startDateAsDate, endDateAsDate),
        courseId,
      },
      relations: ['user'],
    });

    const [checkinEvents, otherEvents] = partition(
      taEvents,
      (e) => e.eventType === EventType.TA_CHECKED_IN,
    );

    const taCheckinTimes: TACheckinPair[] = [];

    for (const checkinEvent of checkinEvents) {
      let closestEvent: EventModel = null;
      let mostRecentTime = new Date();
      const originalDate = mostRecentTime;

      for (const checkoutEvent of otherEvents) {
        if (
          checkoutEvent.userId === checkinEvent.userId &&
          checkoutEvent.time > checkinEvent.time &&
          checkoutEvent.time.getTime() - checkinEvent.time.getTime() <
            mostRecentTime.getTime() - checkinEvent.time.getTime()
        ) {
          closestEvent = checkoutEvent;
          mostRecentTime = checkoutEvent.time;
        }
      }

      const numHelped = await QuestionModel.count({
        where: {
          taHelpedId: checkinEvent.userId,
          helpedAt: Between(
            checkinEvent.time,
            closestEvent?.time || new Date(),
          ),
        },
      });

      taCheckinTimes.push({
        name: checkinEvent.user.name,
        checkinTime: checkinEvent.time,
        checkoutTime: closestEvent?.time,
        inProgress: mostRecentTime === originalDate,
        forced: closestEvent?.eventType === EventType.TA_CHECKED_OUT_FORCED,
        numHelped,
      });
    }

    return { taCheckinTimes };
  }