results_feed/lib/src/services/firestore_service.dart - dart_ci - Git at Google

 // Copyright (c) 2019, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 import 'package:firebase/firebase.dart' as firebase;
 import 'package:firebase/firestore.dart' as firestore;
 import 'package:quiver/iterables.dart' as iterables;

 class FirestoreService {
   static const bool loginEnabled = true;

   firebase.App app;
   bool get isLoggedIn => app?.auth()?.currentUser != null;

   Future logIn() async {
     if (isLoggedIn) return;
     if (loginEnabled) {
       final provider = firebase.GoogleAuthProvider();
       provider.addScope('openid https://www.googleapis.com/auth/datastore');
       try {
         final user = await app.auth().signInWithPopup(provider);
         // Our application settings already disallow non-org users,
         // so we don't even get to this additional check.
         if (!user.user.email.endsWith('@google.com')) await logOut();
       } catch (e) {
         print(e.toString());
       }
     }
     return;
   }

   Future logOut() => app.auth().signOut();

   Future<List<firestore.DocumentSnapshot>> fetchCommits(
       int beforeIndex, int limit) async {
     final commits = app.firestore().collection('commits');
     var query = commits.orderBy('index', 'desc');
     if (beforeIndex != null) {
       query = query.where('index', '<', beforeIndex);
     }
     query = query.limit(limit);
     return (await query.get()).docs;
   }

   Future<List<firestore.DocumentSnapshot>> fetchChanges(
       int startIndex,
       int endIndex,
       bool failuresOnly,
       bool unapprovedOnly,
       String singleTest) async {
     firestore.Query query = app.firestore().collection('results');
     if (singleTest != null) {
       query = query.where('name', '==', singleTest);
     } else if (failuresOnly) {
       // Because the index contains 'active' and 'approved', we
       // always need to give values for both of them (or neither).
       query = query
           .where('active', '==', true)
           .where('approved', 'in', [false, if (!unapprovedOnly) true]);
     }
     final snapshot = await query
         .where('blamelist_end_index', '>=', startIndex)
         .where('blamelist_end_index', '<=', endIndex)
         .get();
     return snapshot.docs;
   }

   Future<firestore.DocumentSnapshot> fetchReviewInfo(int review) async {
     await getFirebaseClient();

     return app.firestore().doc('reviews/$review').get();
   }

   Future<List<firestore.DocumentSnapshot>> fetchPatchsetInfo(int review) async {
     await getFirebaseClient();
     final collection =
         await app.firestore().collection('reviews/$review/patchsets');
     return (await collection.orderBy('number').get()).docs;
   }

   Future<List<firestore.DocumentSnapshot>> fetchTryChanges(
       int review, int patchset) async {
     final results = app.firestore().collection('try_results');
     final snapshot = await results
         .where('review', '==', review)
         .where('patchset', '==', patchset)
         .get();
     return snapshot.docs;
   }

   Future<List<firestore.DocumentSnapshot>> fetchTryBuilds(int review) async {
     final results = app.firestore().collection('try_builds');
     final snapshot = await results.where('review', '==', review).get();
     return snapshot.docs;
   }

   Future<firestore.DocumentSnapshot> fetchComment(String id) =>
       app.firestore().collection('comments').doc(id).get();

   Future<List<firestore.DocumentSnapshot>> fetchCommentsForRange(
       int start, int end) async {
     final results = app.firestore().collection('comments');
     final snapshot = await results
         .where('blamelist_end_index', '>=', start)
         .where('blamelist_end_index', '<=', end)
         .get();
     return snapshot.docs;
   }

   Future<List<firestore.DocumentSnapshot>> fetchCommentsForReview(
       int review) async {
     final results = app.firestore().collection('comments');
     final snapshot = await results.where('review', '==', review).get();
     return snapshot.docs;
   }

   Future<firestore.DocumentSnapshot> fetchBuild(
       String builder, int index) async {
     final builds = app.firestore().collection('builds');
     final snapshot = await builds
         .where('index', '>=', index)
         .where('builder', '==', builder)
         .orderBy('index', 'asc')
         .limit(1)
         .get();
     return snapshot.docs.first;
   }

   Future<List<firestore.DocumentSnapshot>> fetchBuilders() async {
     final snapshot = await app.firestore().collection('configurations').get();
     return snapshot.docs;
   }

   Future pinResults(int pin, List<String> resultIds) async {
     final collection = app.firestore().collection('results');
     // If resultIds.length > 500, break into multiple batches.
     for (final results in iterables.partition(resultIds, 500)) {
       final batch = app.firestore().batch();
       for (final id in results) {
         batch
             .update(collection.doc(id), fieldsAndValues: ['pinned_index', pin]);
       }
       await batch.commit();
     }
   }

   Future<firestore.DocumentSnapshot> saveComment(bool approve, String comment,
       {List<String> resultIds,
       List<String> tryResultIds,
       int blamelistStart,
       int blamelistEnd,
       int review}) async {
     final reference = await app.firestore().collection('comments').add({
       'author': app.auth().currentUser.email,
       if (comment != null) 'comment': comment,
       'created': DateTime.now(),
       if (approve != null) 'approved': approve,
       if (resultIds != null) 'results': resultIds,
       if (tryResultIds != null) 'try_results': tryResultIds,
       if (blamelistStart != null) 'blamelist_start_index': blamelistStart,
       if (blamelistStart != null) 'blamelist_end_index': blamelistEnd,
       if (review != null) 'review': review
     });
     return reference.get();
   }

   Future<void> saveApprovals(
       {bool approve, List<String> resultIds, List<String> tryResultIds}) async {
     if (approve == null) return;
     // Update approved field in results documents.
     Future<void> approveResults(List<String> ids, String collectionName) async {
       if (ids == null) return;
       // If resultIds.length > 500, break into multiple batches.
       for (final results in iterables.partition(ids, 500)) {
         final batch = app.firestore().batch();
         final collection = app.firestore().collection(collectionName);
         for (final id in results) {
           batch.update(collection.doc(id),
               fieldsAndValues: ['approved', approve]);
         }
         await batch.commit();
       }
     }

     await approveResults(resultIds, 'results');
     await approveResults(tryResultIds, 'try_results');
   }

   Future<void> getFirebaseClient() async {
     if (app != null) return;
     // Firebase api key is public, and must be sent to client for use.
     // It is invalid over any connection except https to the app URL.
     // It is not used for security, only usage accounting.
     app = firebase.initializeApp(
         apiKey: 'AIzaSyBFKKpPdV3xPQU4jPYiMvUnUfhB5pDDMRI',
         authDomain: 'dart-ci.firebaseapp.com',
         databaseURL: 'https://dart-ci.firebaseio.com',
         projectId: 'dart-ci',
         storageBucket: 'dart-ci.appspot.com',
         messagingSenderId: '410721018617');
     await app.auth().setPersistence(firebase.Persistence.LOCAL);
   }
 }

 class StagingFirestoreService extends FirestoreService {
   @override
   Future<void> getFirebaseClient() async {
     if (app != null) return;
     // Firebase api key is public, and must be sent to client for use.
     // It is invalid over any connection except https to the app URL.
     // It is not used for security, only usage accounting.
     app = initializeApp();
     await app.auth().setPersistence(firebase.Persistence.LOCAL);
   }

   static firebase.App initializeApp({String name}) {
     return firebase.initializeApp(
         apiKey: 'AIzaSyBky7KGq1dbVn_J48iAI6oVyKRcMrRanns',
         authDomain: 'dart-ci-staging.firebaseapp.com',
         databaseURL: 'https://dart-ci-staging.firebaseio.com',
         messagingSenderId: '287461583823',
         projectId: 'dart-ci-staging',
         storageBucket: 'dart-ci-staging.appspot.com',
         name: name);
   }
 }

 class TestingFirestoreService extends StagingFirestoreService {
   // TestingFirestoreService uses the Firestore database at
   // dart-ci-staging.
   // It includes local password-based authentication for
   // tests that write to staging.
   @override
   Future<void> getFirebaseClient() async {
     await super.getFirebaseClient();
     await logIn();
   }

   @override
   Future logIn() => logInWithPassword(app);

   static Future<void> logInWithPassword(firebase.App app) async {
     try {
       await app.auth().signInWithEmailAndPassword(
           'dartresultsfeedtestaccount2@example.com', r'');
       // Password must be entered locally before testing.
       // Because this is running in a browser, cannot read password from
       // a file or environment variable. Investigate what testing framework
       // supports for local secrets.
     } catch (e) {
       print(e.toString());
     }
   }
 }

 class FirestoreTestSetup {
   firebase.App app;

   Future<void> initialize() async {
     app = StagingFirestoreService.initializeApp(name: 'testing');
     await TestingFirestoreService.logInWithPassword(app);
   }

   Future<void> writeDocumentsFrom(Map<String, dynamic> documents,
       {bool delete = false}) async {
     for (final keys in iterables.partition(documents.keys, 500)) {
       final batch = app.firestore().batch();
       for (final key in keys) {
         if (delete) {
           batch.delete(app.firestore().doc(key));
         } else {
           batch.set(app.firestore().doc(key), documents[key]);
         }
       }
       await batch.commit();
     }
   }

   Future<void> deleteCommentsForReview(int review) async {
     final snapshot = await app
         .firestore()
         .collection('comments')
         .where('review', '==', review)
         .get();
     for (final document in snapshot.docs) {
       await document.ref.delete();
     }
   }

   Future<int> lastIndex() async {
     final commits = app.firestore().collection('commits');
     var snapshot = await commits.orderBy('index', 'desc').limit(3).get();
     if (snapshot.docs.length < 3) {
       throw Exception('Staging database does not contain 3 commits');
     }
     return snapshot.docs.first.data()['index'];
   }
 }
	// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	import 'package:firebase/firebase.dart' as firebase;
	import 'package:firebase/firestore.dart' as firestore;
	import 'package:quiver/iterables.dart' as iterables;

	class FirestoreService {
	static const bool loginEnabled = true;

	firebase.App app;
	bool get isLoggedIn => app?.auth()?.currentUser != null;

	Future logIn() async {
	if (isLoggedIn) return;
	if (loginEnabled) {
	final provider = firebase.GoogleAuthProvider();
	provider.addScope('openid https://www.googleapis.com/auth/datastore');
	try {
	final user = await app.auth().signInWithPopup(provider);
	// Our application settings already disallow non-org users,
	// so we don't even get to this additional check.
	if (!user.user.email.endsWith('@google.com')) await logOut();
	} catch (e) {
	print(e.toString());
	}
	}
	return;
	}

	Future logOut() => app.auth().signOut();

	Future<List<firestore.DocumentSnapshot>> fetchCommits(
	int beforeIndex, int limit) async {
	final commits = app.firestore().collection('commits');
	var query = commits.orderBy('index', 'desc');
	if (beforeIndex != null) {
	query = query.where('index', '<', beforeIndex);
	}
	query = query.limit(limit);
	return (await query.get()).docs;
	}

	Future<List<firestore.DocumentSnapshot>> fetchChanges(
	int startIndex,
	int endIndex,
	bool failuresOnly,
	bool unapprovedOnly,
	String singleTest) async {
	firestore.Query query = app.firestore().collection('results');
	if (singleTest != null) {
	query = query.where('name', '==', singleTest);
	} else if (failuresOnly) {
	// Because the index contains 'active' and 'approved', we
	// always need to give values for both of them (or neither).
	query = query
	.where('active', '==', true)
	.where('approved', 'in', [false, if (!unapprovedOnly) true]);
	}
	final snapshot = await query
	.where('blamelist_end_index', '>=', startIndex)
	.where('blamelist_end_index', '<=', endIndex)
	.get();
	return snapshot.docs;
	}

	Future<firestore.DocumentSnapshot> fetchReviewInfo(int review) async {
	await getFirebaseClient();

	return app.firestore().doc('reviews/$review').get();
	}

	Future<List<firestore.DocumentSnapshot>> fetchPatchsetInfo(int review) async {
	await getFirebaseClient();
	final collection =
	await app.firestore().collection('reviews/$review/patchsets');
	return (await collection.orderBy('number').get()).docs;
	}

	Future<List<firestore.DocumentSnapshot>> fetchTryChanges(
	int review, int patchset) async {
	final results = app.firestore().collection('try_results');
	final snapshot = await results
	.where('review', '==', review)
	.where('patchset', '==', patchset)
	.get();
	return snapshot.docs;
	}

	Future<List<firestore.DocumentSnapshot>> fetchTryBuilds(int review) async {
	final results = app.firestore().collection('try_builds');
	final snapshot = await results.where('review', '==', review).get();
	return snapshot.docs;
	}

	Future<firestore.DocumentSnapshot> fetchComment(String id) =>
	app.firestore().collection('comments').doc(id).get();

	Future<List<firestore.DocumentSnapshot>> fetchCommentsForRange(
	int start, int end) async {
	final results = app.firestore().collection('comments');
	final snapshot = await results
	.where('blamelist_end_index', '>=', start)
	.where('blamelist_end_index', '<=', end)
	.get();
	return snapshot.docs;
	}

	Future<List<firestore.DocumentSnapshot>> fetchCommentsForReview(
	int review) async {
	final results = app.firestore().collection('comments');
	final snapshot = await results.where('review', '==', review).get();
	return snapshot.docs;
	}

	Future<firestore.DocumentSnapshot> fetchBuild(
	String builder, int index) async {
	final builds = app.firestore().collection('builds');
	final snapshot = await builds
	.where('index', '>=', index)
	.where('builder', '==', builder)
	.orderBy('index', 'asc')
	.limit(1)
	.get();
	return snapshot.docs.first;
	}

	Future<List<firestore.DocumentSnapshot>> fetchBuilders() async {
	final snapshot = await app.firestore().collection('configurations').get();
	return snapshot.docs;
	}

	Future pinResults(int pin, List<String> resultIds) async {
	final collection = app.firestore().collection('results');
	// If resultIds.length > 500, break into multiple batches.
	for (final results in iterables.partition(resultIds, 500)) {
	final batch = app.firestore().batch();
	for (final id in results) {
	batch
	.update(collection.doc(id), fieldsAndValues: ['pinned_index', pin]);
	}
	await batch.commit();
	}
	}

	Future<firestore.DocumentSnapshot> saveComment(bool approve, String comment,
	{List<String> resultIds,
	List<String> tryResultIds,
	int blamelistStart,
	int blamelistEnd,
	int review}) async {
	final reference = await app.firestore().collection('comments').add({
	'author': app.auth().currentUser.email,
	if (comment != null) 'comment': comment,
	'created': DateTime.now(),
	if (approve != null) 'approved': approve,
	if (resultIds != null) 'results': resultIds,
	if (tryResultIds != null) 'try_results': tryResultIds,
	if (blamelistStart != null) 'blamelist_start_index': blamelistStart,
	if (blamelistStart != null) 'blamelist_end_index': blamelistEnd,
	if (review != null) 'review': review
	});
	return reference.get();
	}

	Future<void> saveApprovals(
	{bool approve, List<String> resultIds, List<String> tryResultIds}) async {
	if (approve == null) return;
	// Update approved field in results documents.
	Future<void> approveResults(List<String> ids, String collectionName) async {
	if (ids == null) return;
	// If resultIds.length > 500, break into multiple batches.
	for (final results in iterables.partition(ids, 500)) {
	final batch = app.firestore().batch();
	final collection = app.firestore().collection(collectionName);
	for (final id in results) {
	batch.update(collection.doc(id),
	fieldsAndValues: ['approved', approve]);
	}
	await batch.commit();
	}
	}

	await approveResults(resultIds, 'results');
	await approveResults(tryResultIds, 'try_results');
	}

	Future<void> getFirebaseClient() async {
	if (app != null) return;
	// Firebase api key is public, and must be sent to client for use.
	// It is invalid over any connection except https to the app URL.
	// It is not used for security, only usage accounting.
	app = firebase.initializeApp(
	apiKey: 'AIzaSyBFKKpPdV3xPQU4jPYiMvUnUfhB5pDDMRI',
	authDomain: 'dart-ci.firebaseapp.com',
	databaseURL: 'https://dart-ci.firebaseio.com',
	projectId: 'dart-ci',
	storageBucket: 'dart-ci.appspot.com',
	messagingSenderId: '410721018617');
	await app.auth().setPersistence(firebase.Persistence.LOCAL);
	}
	}

	class StagingFirestoreService extends FirestoreService {
	@override
	Future<void> getFirebaseClient() async {
	if (app != null) return;
	// Firebase api key is public, and must be sent to client for use.
	// It is invalid over any connection except https to the app URL.
	// It is not used for security, only usage accounting.
	app = initializeApp();
	await app.auth().setPersistence(firebase.Persistence.LOCAL);
	}

	static firebase.App initializeApp({String name}) {
	return firebase.initializeApp(
	apiKey: 'AIzaSyBky7KGq1dbVn_J48iAI6oVyKRcMrRanns',
	authDomain: 'dart-ci-staging.firebaseapp.com',
	databaseURL: 'https://dart-ci-staging.firebaseio.com',
	messagingSenderId: '287461583823',
	projectId: 'dart-ci-staging',
	storageBucket: 'dart-ci-staging.appspot.com',
	name: name);
	}
	}

	class TestingFirestoreService extends StagingFirestoreService {
	// TestingFirestoreService uses the Firestore database at
	// dart-ci-staging.
	// It includes local password-based authentication for
	// tests that write to staging.
	@override
	Future<void> getFirebaseClient() async {
	await super.getFirebaseClient();
	await logIn();
	}

	@override
	Future logIn() => logInWithPassword(app);

	static Future<void> logInWithPassword(firebase.App app) async {
	try {
	await app.auth().signInWithEmailAndPassword(
	'dartresultsfeedtestaccount2@example.com', r'');
	// Password must be entered locally before testing.
	// Because this is running in a browser, cannot read password from
	// a file or environment variable. Investigate what testing framework
	// supports for local secrets.
	} catch (e) {
	print(e.toString());
	}
	}
	}

	class FirestoreTestSetup {
	firebase.App app;

	Future<void> initialize() async {
	app = StagingFirestoreService.initializeApp(name: 'testing');
	await TestingFirestoreService.logInWithPassword(app);
	}

	Future<void> writeDocumentsFrom(Map<String, dynamic> documents,
	{bool delete = false}) async {
	for (final keys in iterables.partition(documents.keys, 500)) {
	final batch = app.firestore().batch();
	for (final key in keys) {
	if (delete) {
	batch.delete(app.firestore().doc(key));
	} else {
	batch.set(app.firestore().doc(key), documents[key]);
	}
	}
	await batch.commit();
	}
	}

	Future<void> deleteCommentsForReview(int review) async {
	final snapshot = await app
	.firestore()
	.collection('comments')
	.where('review', '==', review)
	.get();
	for (final document in snapshot.docs) {
	await document.ref.delete();
	}
	}

	Future<int> lastIndex() async {
	final commits = app.firestore().collection('commits');
	var snapshot = await commits.orderBy('index', 'desc').limit(3).get();
	if (snapshot.docs.length < 3) {
	throw Exception('Staging database does not contain 3 commits');
	}
	return snapshot.docs.first.data()['index'];
	}
	}