com.google.cloud.firestore.Firestore Java Examples

/**
 * Initialize Firestore using default project ID.
 */
public Quickstart() {
  // [START fs_initialize]
  Firestore db = FirestoreOptions.getDefaultInstance().getService();
  // [END fs_initialize]
  this.db = db;
}
 

@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp)
    throws ServletException, IOException {
  Firestore firestore = (Firestore) this.getServletContext().getAttribute("firestore");
  CollectionReference translations = firestore.collection("translations");
  QuerySnapshot snapshot;
  try {
    snapshot = translations.limit(10).get().get();
  } catch (InterruptedException | ExecutionException e) {
    throw new ServletException("Exception retrieving documents from Firestore.", e);
  }
  List<TranslateMessage> translateMessages = Lists.newArrayList();
  List<QueryDocumentSnapshot> documents = Lists.newArrayList(snapshot.getDocuments());
  documents.sort(Comparator.comparing(DocumentSnapshot::getCreateTime));

  for (DocumentSnapshot document : Lists.reverse(documents)) {
    String encoded = gson.toJson(document.getData());
    TranslateMessage message = gson.fromJson(encoded, TranslateMessage.class);
    message.setData(decode(message.getData()));
    translateMessages.add(message);
  }
  req.setAttribute("messages", translateMessages);
  req.setAttribute("page", "list");
  req.getRequestDispatcher("/base.jsp").forward(req, resp);
}
 

@Test
public void testFirestoreOptionsOverride() throws IOException {
  FirebaseApp app = FirebaseApp.initializeApp(new Builder()
      .setCredentials(GoogleCredentials.fromStream(ServiceAccount.EDITOR.asStream()))
      .setProjectId("explicit-project-id")
      .setFirestoreOptions(FirestoreOptions.newBuilder()
          .setTimestampsInSnapshotsEnabled(true)
          .setProjectId("other-project-id")
          .setCredentials(GoogleCredentials.fromStream(ServiceAccount.EDITOR.asStream()))
          .build())
      .build());
  Firestore firestore = FirestoreClient.getFirestore(app);
  assertEquals("explicit-project-id", firestore.getOptions().getProjectId());
  assertTrue(firestore.getOptions().areTimestampsInSnapshotsEnabled());
  assertSame(ImplFirebaseTrampolines.getCredentials(app),
      firestore.getOptions().getCredentialsProvider().getCredentials());

  firestore = FirestoreClient.getFirestore();
  assertEquals("explicit-project-id", firestore.getOptions().getProjectId());
  assertTrue(firestore.getOptions().areTimestampsInSnapshotsEnabled());
  assertSame(ImplFirebaseTrampolines.getCredentials(app),
      firestore.getOptions().getCredentialsProvider().getCredentials());
}
 

@Test
public void testFirestoreAccess() throws Exception {
  Firestore firestore = FirestoreClient.getFirestore(IntegrationTestUtils.ensureDefaultApp());
  DocumentReference reference = firestore.collection("cities").document("Mountain View");
  ImmutableMap<String, Object> expected = ImmutableMap.<String, Object>of(
      "name", "Mountain View",
      "country", "USA",
      "population", 77846L,
      "capital", false
  );
  WriteResult result = reference.set(expected).get();
  assertNotNull(result);

  Map<String, Object> data = reference.get().get().getData();
  assertEquals(expected.size(), data.size());
  for (Map.Entry<String, Object> entry : expected.entrySet()) {
    assertEquals(entry.getValue(), data.get(entry.getKey()));
  }

  reference.delete().get();
  assertFalse(reference.get().get().exists());
}
 

@Test
public void writeDocumentFromObject() throws ExecutionException, InterruptedException {
	this.contextRunner.run((context) -> {
		Firestore firestore = context.getBean(Firestore.class);
		FirestoreExample firestoreExample = new FirestoreExample(firestore);

		firestoreExample.writeDocumentFromObject();
		User user = firestoreExample.readDocumentToObject();
		assertThat(user).isEqualTo(new User("Joe",
				Arrays.asList(
						new Phone(12345, PhoneType.CELL),
						new Phone(54321, PhoneType.WORK))));

		firestoreExample.writeDocumentFromObject2();
		user = firestoreExample.readDocumentToObject();
		assertThat(user).isEqualTo(new User("Joseph",
				Arrays.asList(
						new Phone(23456, PhoneType.CELL),
						new Phone(65432, PhoneType.WORK))));
	});
}
 

@Override
public void preConfig(ElepyPreConfiguration elepy) {

    if (enableFirestore) {
        elepy.registerDependency(Firestore.class, FirestoreClient.getFirestore(app));
        elepy.withDefaultCrudFactory(FirestoreCrudFactory.class);
    }

    if (bucketName != null) {
        StorageClient client = StorageClient.getInstance(app);
        elepy.withUploads(new CloudStorageFileService(client.bucket(bucketName).getStorage(), bucketName));
    }
}
 

@AfterClass
public static void tearDownClass() throws ExecutionException, InterruptedException {
  // Clear the firestore sessions data.
  Firestore firestore = FirestoreOptions.getDefaultInstance().getService();
  for (QueryDocumentSnapshot docSnapshot :
      firestore.collection("books").get().get().getDocuments()) {
    docSnapshot.getReference().delete().get();
  }

  service.stop();
}
 

protected  static void deleteAllDocuments(Firestore db) throws Exception {
  ApiFuture<QuerySnapshot> future = db.collection("cities").get();
  QuerySnapshot querySnapshot = future.get();
  for (DocumentSnapshot doc : querySnapshot.getDocuments()) {
    // block on delete operation
    db.collection("cities").document(doc.getId()).delete().get();
  }
}
 

public Quickstart(String projectId) throws Exception {
  // [START fs_initialize_project_id]
  FirestoreOptions firestoreOptions =
      FirestoreOptions.getDefaultInstance().toBuilder()
          .setProjectId(projectId)
          .setCredentials(GoogleCredentials.getApplicationDefault())
          .build();
  Firestore db = firestoreOptions.getService();
  // [END fs_initialize_project_id]
  this.db = db;
}
 

@SuppressWarnings("JavadocMethod")
public static Firestore getFirestore() {
  if (firestore == null) {
    // Authorized Firestore service
    // [START gae_java11_firestore]
    Firestore db =
        FirestoreOptions.newBuilder().setProjectId("YOUR-PROJECT-ID").build().getService();
    // [END gae_java11_firestore]
    firestore = db;
  }

  return firestore;
}
 

@AfterClass
public static void tearDownClass() throws ExecutionException, InterruptedException {
  // Clear the firestore list if we're not using the local emulator
  Firestore firestore = FirestoreOptions.getDefaultInstance().getService();
  for (QueryDocumentSnapshot docSnapshot :
      firestore.collection("translations").get().get().getDocuments()) {
    try {
      docSnapshot.getReference().delete().get();
    } catch (InterruptedException | ExecutionException e) {
      e.printStackTrace();
    }
  }

  service.stop();
}
 

@Override
public void contextInitialized(ServletContextEvent event) {
  String firestoreProjectId = System.getenv("FIRESTORE_CLOUD_PROJECT");
  Firestore firestore = (Firestore) event.getServletContext().getAttribute("firestore");
  if (firestore == null) {
    firestore =
        FirestoreOptions.getDefaultInstance().toBuilder()
            .setProjectId(firestoreProjectId)
            .build()
            .getService();
    event.getServletContext().setAttribute("firestore", firestore);
  }

  Translate translate = (Translate) event.getServletContext().getAttribute("translate");
  if (translate == null) {
    translate = TranslateOptions.getDefaultInstance().getService();
    event.getServletContext().setAttribute("translate", translate);
  }

  Publisher publisher = (Publisher) event.getServletContext().getAttribute("publisher");
  if (publisher == null) {
    try {
      String topicId = System.getenv("PUBSUB_TOPIC");
      publisher =
          Publisher.newBuilder(
                  ProjectTopicName.newBuilder()
                      .setProject(firestoreProjectId)
                      .setTopic(topicId)
                      .build())
              .build();
      event.getServletContext().setAttribute("publisher", publisher);
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}
 

@Test
public void testDatastoreOptionsCorrectlySet() {
	this.contextRunner.run((context) -> {
		FirestoreOptions datastoreOptions = context.getBean(Firestore.class).getOptions();
		assertThat(datastoreOptions.getProjectId()).isEqualTo("test-project");
	});
}
 

@Test
public void testFirestoreOptions() throws IOException {
  FirebaseApp app = FirebaseApp.initializeApp(new Builder()
      .setCredentials(GoogleCredentials.fromStream(ServiceAccount.EDITOR.asStream()))
      .setProjectId("explicit-project-id")
      .setFirestoreOptions(FIRESTORE_OPTIONS)
      .build());
  Firestore firestore = FirestoreClient.getFirestore(app);
  assertEquals("explicit-project-id", firestore.getOptions().getProjectId());
  assertTrue(firestore.getOptions().areTimestampsInSnapshotsEnabled());

  firestore = FirestoreClient.getFirestore();
  assertEquals("explicit-project-id", firestore.getOptions().getProjectId());
  assertTrue(firestore.getOptions().areTimestampsInSnapshotsEnabled());
}
 

@Test
public void testServiceAccountProjectId() throws IOException {
  FirebaseApp app = FirebaseApp.initializeApp(new FirebaseOptions.Builder()
      .setCredentials(GoogleCredentials.fromStream(ServiceAccount.EDITOR.asStream()))
      .setFirestoreOptions(FIRESTORE_OPTIONS)
      .build());
  Firestore firestore = FirestoreClient.getFirestore(app);
  assertEquals("mock-project-id", firestore.getOptions().getProjectId());

  firestore = FirestoreClient.getFirestore();
  assertEquals("mock-project-id", firestore.getOptions().getProjectId());
}
 

@Test
public void testExplicitProjectId() throws IOException {
  FirebaseApp app = FirebaseApp.initializeApp(new FirebaseOptions.Builder()
      .setCredentials(GoogleCredentials.fromStream(ServiceAccount.EDITOR.asStream()))
      .setProjectId("explicit-project-id")
      .setFirestoreOptions(FIRESTORE_OPTIONS)
      .build());
  Firestore firestore = FirestoreClient.getFirestore(app);
  assertEquals("explicit-project-id", firestore.getOptions().getProjectId());

  firestore = FirestoreClient.getFirestore();
  assertEquals("explicit-project-id", firestore.getOptions().getProjectId());
}
 

FirestoreExample(Firestore firestore) {
	this.firestore = firestore;
}
 

FirebaseFirestoreReactive(Firestore firestore) {
  this.firestore = firestore;
}
 

public Firestore getClient() {
  return client;
}
 

@Override
public <T> Crud<T> crudFor(Schema<T> type) {
    return new FirestoreCrud<>(elepyContext.getDependency(Firestore.class), type);
}
 

ListenDataSnippets(Firestore db) {
  this.db = db;
}
 

ManageDataSnippets(Firestore db) {
  this.db = db;
}
 

public References(Firestore db) {
  this.db = db;
}
 

QueryDataSnippets(Firestore db) {
  this.db = db;
}
 

RetrieveDataSnippets(Firestore db) {
  this.db = db;
}
 

Firestore getDb() {
  return db;
}
 

public FirestoreCrud(Firestore db, Schema<T> schema) {
    this.db = db;
    this.objectMapper = new ObjectMapper();
    this.collection = schema.getPath();
    this.schema = schema;
}
 

public static void setFirestore(Firestore firestore) {
  Persistence.firestore = firestore;
}
 

public FirestoreDao() {
  Firestore firestore = FirestoreOptions.getDefaultInstance().getService();
  booksCollection = firestore.collection("books");
}
 

/**
 * Handle a posted message from Pubsub.
 *
 * @param req The message Pubsub posts to this process.
 * @param resp Not used.
 */
@Override
public void doPost(HttpServletRequest req, HttpServletResponse resp)
    throws IOException, ServletException {

  // Block requests that don't contain the proper verification token.
  String pubsubVerificationToken = PUBSUB_VERIFICATION_TOKEN;
  if (req.getParameter("token").compareTo(pubsubVerificationToken) != 0) {
    resp.setStatus(HttpServletResponse.SC_BAD_REQUEST);
    return;
  }

  // [START getting_started_background_translate_string]
  String body = req.getReader().lines().collect(Collectors.joining(System.lineSeparator()));

  PubSubMessage pubsubMessage = gson.fromJson(body, PubSubMessage.class);
  TranslateMessage message = pubsubMessage.getMessage();

  // Use Translate service client to translate the message.
  Translate translate = (Translate) this.getServletContext().getAttribute("translate");
  message.setData(decode(message.getData()));
  Translation translation =
      translate.translate(
          message.getData(),
          Translate.TranslateOption.sourceLanguage(message.getAttributes().getSourceLang()),
          Translate.TranslateOption.targetLanguage(message.getAttributes().getTargetLang()));
  // [END getting_started_background_translate_string]

  message.setTranslatedText(translation.getTranslatedText());

  try {
    // [START getting_started_background_translate]
    // Use Firestore service client to store the translation in Firestore.
    Firestore firestore = (Firestore) this.getServletContext().getAttribute("firestore");

    CollectionReference translations = firestore.collection("translations");

    ApiFuture<WriteResult> setFuture = translations.document().set(message, SetOptions.merge());

    setFuture.get();
    resp.getWriter().write(translation.getTranslatedText());
    // [END getting_started_background_translate]
  } catch (InterruptedException | ExecutionException e) {
    throw new ServletException("Exception storing data in Firestore.", e);
  }
}