将角消防员图书馆放置 - II

// category.model

// mapping new instance
export interface icategory {
  name: string | null;
  id: string | null;
  key?: string;
}

// static class or export functions, it's a designers choice
export class category {
  public static newinstance(data: querydocumentsnapshot): icategory {
    if (data === null) {
      return null;
    }
    const d = data.data();
    return {
      id: data.id,
      name: d['name'],
      key: d['key']
    };
  }

  // receives querysnapshot and maps out the `data() ` and id
  public static newinstances(data: querysnapshot): icategory[] {
    // read docs array 
    return data.docs.map(n => category.newinstance(n));
  }

}

// category.service

 getcategories(params: iwhere[] = []): observable<icategory[]> {
    // ...
    return from(getdocs(_query)).pipe(
      map((res: querysnapshot) => {
        // here map
        return category.newinstances(res);
      })
    );
}
getcategory(id: string): observable<icategory> {
    return from(getdoc(doc(this.db, 'categories', id))).pipe(
      map((res: documentsnapshot) => {
        // map
        return category.newinstance(res);
      }),
    );
}

// components/categories.list

addnew() {
    // read form:
    const newcat: partial<icategory> = this.fg.value;

    this.categoryservice.createcategory(newcat).subscribe({
      next: (res) => {
        // the category list should be updated here
       console.log(res);
      }
    });
}

// category.service
createcategory(category: partial<icategory>): observable<any> {
    return from(adddoc(collection(this.db, 'categories'), category)).pipe(
      map(res => {
        // i have nothing but id!
        return {...category, id: res.id};

      })
    );
}

// category.model

// adjust newinstance to accept partial category
public static newinstance(data: documentsnapshot | partial<icategory>, id?: string): icategory {
    if (data === null) {
      return null;
    }

    const d = data instanceof documentsnapshot ? data.data() : data;
    return {
      id: data.id || id, // if data.id doesnt exist (as in adddoc)
      name: d['name'],
      key: d['key']
    };
}

// category.service

createcategory(category: partial<icategory>): observable<icategory> {

    return from(adddoc(collection(this.db, 'categories'), category)).pipe(
      map(res => {
        // update to pass category and res.id
        return category.newinstance(category, res.id);
      }),
    );

}

// add a new documnet with a new generated id
adddoc(collection(this.db, 'categories'), {name: 'bubbles', key: 'bubbles'});

// update and existing document, this will throw an error if non existent
updatedoc(existingcategoryref, {name: 'bubbles'})

// an alternative way to create
createcategory(category: partial<icategory>): observable<icategory> {

    // new auto generated id
    const ref = doc(collection(this.db, 'categories'));

    return from(setdoc(ref, category)).pipe(
       map(_ => {
         // response is void, id is in original ref
         return category.newinstance(category, ref.id);
       })
    );
}

// category.sevice

// id must be passed in category
updatecategory(category: partial<icategory>): observable<icategory> {
    return from(updatedoc(doc(this.db, 'categories', category.id), category)).pipe(
      map(_ => {
        // response is void
        // why do we do this? because you never know in the future what other changes you might need to make before returning
        return category.newinstance(category);
      })
    );
}

// categories/list.component
update(category: icategory) {
    // gather field values
    const cat: partial<icategory> = this.ufg.value;

    // make sure the id is passed
    this.categoryservice.updatecategory({...cat, id: category.id}).subscribe({
      next: (res) => {
        console.log(res); // this has the same category after update
      }
    });
  }

// category.sevice

deletecategory(id: string): observable<boolean> {
    return from(deletedoc(doc(this.db, 'categories', id))).pipe(
      // response is void, but we might want to differentiate failures later
      map(_ => true)
    );
}

// category/list.component

delete(category: icategory) {
    this.categoryservice.deletecategory(category.id).subscribe({
      next: (res) => {
        console.log('success!', res);
      }
    });
}

// where.model

// the param fields object (yes its plural)
export interface ifieldoptions {
    label?: string; // exmaple
    key?: string;

    // other example fields
    month?: date;
    recent?: boolean;
    maxprice?: number;
}


// map fields to where conditions of the proper firestore keys

export const maplistoptions = (options?: ifieldoptions): iwhere[] => {

    let c: any[] = [];
    if (!options) return [];

    if (options.label) {
      // mapping label to name
      c.push({ fieldpath: 'name', opstr: '==', value: options.label });
    }

    if(options.key) {
      c.push({ fieldpath: 'key', opstr: '==', value: options.key });
    }
    // maxprice is a less than or equal operator
    if (options.maxprice) {
        c.push({ fieldpath: 'price', opstr: '<=', value: options.maxprice });
    }

    if (options.month) {
        // to implement, push only data of the same month
        c.push(...mapmonth(options.month));
    }

    if (options.recent) {
        const lastweek = new date();
        lastweek.setdate(lastweek.getdate() - 7);
        // things that happened since last week:
        c.push({ fieldpath: 'date', opstr: '>=', value: lastweek });
    }

    return c;
}

// category.sevice

// accept options of specific fields
getcategories(params?: ifieldoptions): observable<icategory[]> {
    // translate fields to where:
    const _where: any[] = (mapfieldoptions(fieldoptions))
        .map(n => where(n.fieldpath, n.opstr, n.value));

    // pass the where to query
    const _query = query(collection(this.db, this._url), ..._where);

    // ... getdocs
}

// somemodel

// use timestamp class to map from and to dates

const jsdate = new date();

// adddoc with
const newdata = {
    fbdate: timestamp.fromdate(jsdate)
}

// documentsnapshot returns data() with date field, the type is timestamp
// use todate to convert to js date
return data['fbdate'].todate();

// http.service

@injectable({ providedin: 'root' })
export class httpservice {
  public run(fn: observable<any>): observable<any> {

    // show loader here
    showloader();

    // return function as is
    return fn
      .pipe(
        // hide loader
        finalize(() => hideloader()),
        // debug and catcherrors as well here
      );
  }
}

// category.service

private httpservice = inject(httpservice);

getcategories(params?: iwhere[]): observable<icategory[]> {
    // ...
    // wrap in run
    return this.httpservice.run(from(getdocs(q)).pipe(
      map((res: querysnapshot) => {
        return category.newinstances(res);
      })
    ));
}

// http.service
// ...
public run<t>(fn: observable<any>): observable<t> {
    // ...
}

// category.service
return this.httpService.run<ICategory[]>(from(getDocs(q)).pipe(
  map((res: QuerySnapshot) => {
    return Category.NewInstances(res);
  })
));