TypeScript mongodb.ObjectID类代码示例

  public findOneById(userId: string, markId: string): Promise<Mark> {
    assert(userId);
    assert(markId);

    const query = {
      "_id": ObjectID.createFromHexString(markId),
      "user._id": ObjectID.createFromHexString(userId)
    };

    return this.findOne(query);
  }

 it('equal players with entity ids are equal', function () {
     const batman = {
         name: 'Batman',
         _id: ObjectID.createFromHexString('000000079bb31fb01ee7834c'),
         tribe: 'what'
     };
     const anotherBatman = {
         name: 'Batman',
         _id: ObjectID.createFromHexString('000000079bb31fb01ee7834c'),
         tribe: 'what'
     };
     expect(Comparators.areEqualPlayers(batman, anotherBatman)).toBe(true);
 })

      const addIdsToQueryMap = (access: boolean) => (id: string | ObjectID) => {
        const accessString = access ? 'positive' : 'negative';
        const altAccessString = access ? 'negative' : 'positive';
        const resourceUid = Tyr.byName[linkedCollectionName].idToUid(id);

        if (alreadySet.has(resourceUid)) {
          return;
        } else {
          alreadySet.add(resourceUid);
        }

        const accessSet =
          queryMaps[accessString].get(linkedCollectionName) || new Set();
        if (!queryMaps[accessString].has(linkedCollectionName)) {
          queryMaps[accessString].set(linkedCollectionName, accessSet);
        }

        // if the id was set previously, by a lower level link,
        // dont override the lower level
        const map = queryMaps[altAccessString].get(linkedCollectionName);

        if (!map || !map.has(id.toString())) {
          accessSet.add(id as string);
        }
      };

export default async function(ctx: Koa.Context) {
	// Validate id
	if (!mongodb.ObjectID.isValid(ctx.params.id)) {
		ctx.throw(400, 'incorrect id');
		return;
	}

	const fileId = new mongodb.ObjectID(ctx.params.id);

	// Fetch drive file
	const file = await DriveFile.findOne({ _id: fileId });

	if (file == null) {
		ctx.status = 404;
		await send(ctx, '/dummy.png', { root: assets });
		return;
	}

	if (file.metadata.deletedAt) {
		ctx.status = 410;
		await send(ctx, '/tombstone.png', { root: assets });
		return;
	}

	if (file.metadata.withoutChunks) {
		ctx.status = 204;
		return;
	}

	const sendRaw = async () => {
		const bucket = await getDriveFileBucket();
		const readable = bucket.openDownloadStream(fileId);
		readable.on('error', commonReadableHandlerGenerator(ctx));
		ctx.set('Content-Type', file.contentType);
		ctx.body = readable;
	};

	if ('thumbnail' in ctx.query) {
		const thumb = await DriveFileThumbnail.findOne({
			'metadata.originalId': fileId
		});

		if (thumb != null) {
			ctx.set('Content-Type', 'image/jpeg');
			const bucket = await getDriveFileThumbnailBucket();
			ctx.body = bucket.openDownloadStream(thumb._id);
		} else {
			await sendRaw();
		}
	} else {
		if ('download' in ctx.query) {
			ctx.set('Content-Disposition', 'attachment');
		}

		await sendRaw();
	}
}

	connection.on('message', async (data) => {
		const msg = JSON.parse(data.utf8Data);

		switch (msg.type) {
			case 'read':
					if (!msg.id) {
						return;
					}

					const id = new mongodb.ObjectID(msg.id);

					// Fetch message
					// SELECT _id, user_id, is_read
					const message = await Message.findOne({
						_id: id,
						recipient_id: user._id
					}, {
						fields: {
							_id: true,
							user_id: true,
							is_read: true
						}
					});

					if (message == null) {
						return;
					}

					if (message.is_read) {
						return;
					}

					// Update documents
					await Message.update({
						_id: id
					}, {
						$set: { is_read: true }
					});

					// Publish event
					publishMessagingStream(message.user_id, user._id, 'read', id.toString());
				break;
		}
	});

  public findByVerse(userId: string, verseId: ObjectID, options: any): Promise<Mark[]> {
    assert(userId);
    assert(verseId);

    const query = {
      "user._id": ObjectID.createFromHexString(userId),
      "verse._id": verseId
    };

    return this.find(query, options);
  }

    it("should correctly diff ObjectIDs", function () {
        let oldID = new MongoDB.ObjectID();
        let newID = MongoDB.ObjectID.createFromHexString(oldID.toHexString());

        let oldObject = { _id: oldID };
        let newObject = { _id: newID };
        let expectedDiff = {

        };

        chai.expect(Omnom.diff(oldObject, newObject)).to.exist.and.be.eql(expectedDiff);

        newID = new MongoDB.ObjectID();

        oldObject = { _id: oldID };
        newObject = { _id: newID };
        expectedDiff = {
            $set: { _id: newID }
        };

        chai.expect(Omnom.diff(oldObject, newObject)).to.exist.and.be.eql(expectedDiff);
    });

  public findByTag(userId: string, tags: string[]): Promise<Mark[]> {
    assert(userId);
    assert(tags);

    const query = {
      "user._id": ObjectID.createFromHexString(userId),
      "tag": {
        $in: tags
      }
    };

    return this.find(query);
  }

			return this.dbExecute<TEntity>((collection: Collection, subject: Subject<TEntity>) => {
				const id: ObjectID = new ObjectID(entity._id);
				delete entity._id;
				entity.lastUpdated = new Date();
				collection.replaceOne({ _id: id }, entity, (err: WriteError, result: UpdateWriteOpResult) => {
					if (err) {
						throw new Error(err.errmsg);
					}

					console.log(result.toString());
					entity._id = id.toHexString();
					subject.next(entity);
					subject.complete();
				});
			});

				collection.replaceOne({ _id: id }, entity, (err: WriteError, result: UpdateWriteOpResult) => {
					if (err) {
						throw new Error(err.errmsg);
					}

					console.log(result.toString());
					entity._id = id.toHexString();
					subject.next(entity);
					subject.complete();
				});