private updateUser(data: any): Promise<void> {
   const userRef: AngularFirestoreDocument<any> = this.afs.doc(`users/${data.id}`);
   return userRef.set(data, { merge: true });
 }

 constructor(private db: AngularFirestore) { 
     this.rodadas = db.collection(config.rodadaDB);
 }

 constructor(private db: AngularFirestore, private jogoService: JogoService, private cookieService: CookieService) { 
     this.jogadores = db.collection(config.jogadorDB);
 }

 col<T>(ref: CollectionPredicate<T>, queryFn?): AngularFirestoreCollection<T> {
     return typeof ref === 'string' ? this.afs.collection<T>(ref, queryFn) : ref;
 }

 constructor(private afs: AngularFirestore) {
   this.notesCollection = this.afs.collection('notes', (ref) => ref.orderBy('time', 'desc').limit(5));
 }

 constructor(
     private afs: AngularFirestore
 ) {
     this.booksCollection = this.afs.collection('books');
 }

  private async oAuthLogin(provider) {
    const loginAction = await this.afAuth.auth.signInWithPopup(provider);
    const userRef = await this.afs.doc(`users/${loginAction.user.uid}`).valueChanges().pipe(first()).toPromise();

    const updateObject: any = {
      id: loginAction.user.uid,
      displayName: loginAction.user.displayName,
      emailVerified: true,
      email: loginAction.user.email,
      creationTime: loginAction.user.metadata.creationTime,
      lastSignInTime: loginAction.user.metadata.lastSignInTime
    };

    if (!userRef) {
      const registrationData = await this.applicationService.getAppData().toPromise();
      updateObject.assignedRoles = {
        admin: registrationData.registration && registrationData.registration === 'admin',
        editor: registrationData.registration && registrationData.registration === 'editor',
        subscriber: registrationData.registration && registrationData.registration === 'subscriber'
      };
    }
    return this.updateUser(updateObject);
  }

  loginJobs() {
    const user = this.afAuth.auth.currentUser;
    const userInfo: User = {
      uid: user.uid,
      displayName: user.displayName,
      email: user.email,
      phoneNumber: user.phoneNumber,
      photoURL: user.photoURL,
      logged:true
    }

    this.afs.
      collection<User>(`users`)
      .doc(user.uid)
      .set({ ...userInfo })
      .then(res => {
        console.log(res);
      }).catch(err => {
        alert(err)
      })
    this.storage.set('user', userInfo)
    this.events.publish('user:login', user)
  }

    private async savePhoto(path: string, displayName: string, uid: string, lexeme: string, dictionaryId: string) {
        try {
            // tslint:disable:max-line-length
            const storagePath = 'https://anet-photo.appspot.com/urlfull/talking-dictionaries-' + (environment.production ? 'alpha' : 'dev') + '.appspot.com/' + path;

            const result = await this.http.get(storagePath, { responseType: 'text' }).toPromise();
            const gcsPath: string = result.replace('http://lh3.googleusercontent.com/', '');

            const pf: IPhoto = {
                path,
                gcs: gcsPath,
                ts: firestore.FieldValue.serverTimestamp(),
                cr: displayName,
                ab: uid,
            };

            const entryDoc = this.afs.doc(`dictionaries/${dictionaryId}/words/${this.entry.id}`);
            await entryDoc.update({ pf });
            this.snackBar.open(`Photo uploaded for ${lexeme}`, '', { duration: 3000 });
        } catch (err) {
            this.snackBar.open('Error Uploading Image. Please email Jacob image name and lexeme.', 'OK',
                { duration: 20000, panelClass: 'snackbar-error' });
        }
    }

 updateJogo(id, update) {
     this.jogosDoc = this.db.doc<Jogo>(`${config.jogoDB}/${id}`);
     this.jogosDoc.update(update);
 }

 this.dictionariesService.currentDictionary.pipe(take(1)).subscribe(dictionary => {
   this.afs.collection(`dictionaries/${dictionary.id}/writeInCollaborators`).add(writeInCollaborator);
 });

 getNote(id: string) {
   return this.afs.doc<any>(`notes/${id}`);
 }

 switchMap((dictionary) => {
   return this.afs.doc<DictionarySettings>(`dictionaries/${dictionary.id}/config/settings`).valueChanges();
 })

 deletejogador(id, jogoId) {
     this.jogadorDoc = this.db.doc<Jogador>(`${config.jogoDB}/${jogoId}/${config.jogadorDB}/${id}`);
     this.jogadorDoc.delete();
 }

 updatejogador(id, update, jogoId) {
     this.jogadorDoc = this.db.doc<Jogador>(`${config.jogoDB}/${jogoId}/${config.jogadorDB}/${id}`);
     this.jogadorDoc.update(update);
 }

 setJogo (jogoId) {
     this.jogadores = this.db.collection(config.jogoDB).doc(jogoId).collection(config.jogadorDB);
 }

  public getCollection$(userId: string, query?): Observable<Day[]> {

    return this.angularFirestore.collection<Day>(`users/${userId}/timesheet`).valueChanges();
  }

 public add(userId: string, data: Day): Promise<DocumentReference> {
   return this.angularFirestore.collection<Day>(`users/${userId}/timesheet`).add(data);
 }

 deleteJogo(id) {
     this.jogosDoc = this.db.doc<Jogo>(`${config.jogoDB}/${id}`);
     this.jogosDoc.delete();
 }

  createshippings(data: Billing) {
    //this.shippings.push(data);
    this.db.collection('shippings').add(data);

  }