@blackcode_sa/metaestetics-api 1.11.3 → 1.12.0

package/src/backoffice/services/documentation-template.service.ts

@@ -21,8 +21,10 @@ export class DocumentationTemplateServiceBackoffice {
    * @param auth - Firebase Auth instance
    * @param app - Firebase App instance
    */
-  constructor(db: Firestore, auth: Auth, app: FirebaseApp) {
-    this.apiService = new ApiDocumentationTemplateService(db, auth, app);
+  constructor(
+    ...args: ConstructorParameters<typeof ApiDocumentationTemplateService>
+  ) {
+    this.apiService = new ApiDocumentationTemplateService(...args);
   }
 
   /**
@@ -88,6 +90,58 @@ export class DocumentationTemplateServiceBackoffice {
     return this.apiService.getActiveTemplates(pageSize, lastDoc);
   }
 
+  /**
+   * Get all active templates with optional filters and pagination.
+   * @param options - Options for filtering and pagination.
+   * @returns A promise that resolves to the templates and the last visible document.
+   */
+  async getTemplates(options: {
+    pageSize?: number;
+    lastDoc?: QueryDocumentSnapshot<DocumentTemplate>;
+    isUserForm?: boolean;
+    isRequired?: boolean;
+    sortingOrder?: number;
+  }): Promise<{
+    templates: DocumentTemplate[];
+    lastDoc: QueryDocumentSnapshot<DocumentTemplate> | null;
+  }> {
+    return this.apiService.getTemplates(options);
+  }
+
+  /**
+   * Get the total count of active templates with optional filters.
+   * @param options - Options for filtering.
+   * @returns A promise that resolves to the total count of templates.
+   */
+  async getTemplatesCount(options: {
+    isUserForm?: boolean;
+    isRequired?: boolean;
+    sortingOrder?: number;
+    search?: string;
+  }): Promise<number> {
+    return this.apiService.getTemplatesCount(options);
+  }
+
+  /**
+   * Get all active templates without pagination for filtering purposes.
+   * @returns A promise that resolves to an array of all active templates.
+   */
+  async getAllActiveTemplates(): Promise<DocumentTemplate[]> {
+    return this.apiService.getAllActiveTemplates();
+  }
+
+  /**
+   * Searches for active templates by title.
+   * @param title - The title to search for.
+   * @returns A list of templates that match the search criteria.
+   */
+  async search(title: string): Promise<DocumentTemplate[]> {
+    const { templates } = await this.apiService.getActiveTemplates(1000); // A large number to get all templates
+    return templates.filter((t) =>
+      t.title.toLowerCase().includes(title.toLowerCase())
+    );
+  }
+
   /**
    * Get templates by tags
    * @param tags - Tags to filter by

package/src/backoffice/services/index.ts

@@ -5,3 +5,4 @@ export * from "./product.service";
 export * from "./requirement.service";
 export * from "./subcategory.service";
 export * from "./technology.service";
+export * from "./constants.service";

package/src/backoffice/services/product.service.ts

@@ -1,12 +1,18 @@
 import {
   addDoc,
   collection,
+  collectionGroup,
   doc,
   getDoc,
   getDocs,
   query,
   updateDoc,
   where,
+  limit,
+  orderBy,
+  startAfter,
+  getCountFromServer,
+  QueryConstraint,
 } from "firebase/firestore";
 import {
   Product,
@@ -43,6 +49,7 @@ export class ProductService extends BaseService implements IProductService {
     >
   ): Promise<Product> {
     const now = new Date();
+    // categoryId and subcategoryId are now expected to be part of the product object
     const newProduct: Omit<Product, "id"> = {
       ...product,
       brandId,
@@ -61,21 +68,135 @@ export class ProductService extends BaseService implements IProductService {
   }
 
   /**
-   * Gets all products for a technology
+   * Gets a paginated list of all products, with optional filters.
+   * This uses a collectionGroup query to search across all technologies.
    */
-  async getAllByTechnology(technologyId: string): Promise<Product[]> {
+  async getAll(options: {
+    rowsPerPage: number;
+    lastVisible?: any;
+    categoryId?: string;
+    subcategoryId?: string;
+    technologyId?: string;
+  }): Promise<{ products: Product[]; lastVisible: any }> {
+    const {
+      rowsPerPage,
+      lastVisible,
+      categoryId,
+      subcategoryId,
+      technologyId,
+    } = options;
+
+    const constraints: QueryConstraint[] = [
+      where("isActive", "==", true),
+      orderBy("name"),
+    ];
+
+    if (categoryId) {
+      constraints.push(where("categoryId", "==", categoryId));
+    }
+    if (subcategoryId) {
+      constraints.push(where("subcategoryId", "==", subcategoryId));
+    }
+    if (technologyId) {
+      constraints.push(where("technologyId", "==", technologyId));
+    }
+
+    if (lastVisible) {
+      constraints.push(startAfter(lastVisible));
+    }
+    constraints.push(limit(rowsPerPage));
+
     const q = query(
-      this.getProductsRef(technologyId),
-      where("isActive", "==", true)
+      collectionGroup(this.db, PRODUCTS_COLLECTION),
+      ...constraints
     );
     const snapshot = await getDocs(q);
-    return snapshot.docs.map(
+
+    const products = snapshot.docs.map(
       (doc) =>
         ({
           id: doc.id,
           ...doc.data(),
         } as Product)
     );
+    const newLastVisible = snapshot.docs[snapshot.docs.length - 1];
+
+    return { products, lastVisible: newLastVisible };
+  }
+
+  /**
+   * Gets the total count of active products, with optional filters.
+   */
+  async getProductsCount(options: {
+    categoryId?: string;
+    subcategoryId?: string;
+    technologyId?: string;
+  }): Promise<number> {
+    const { categoryId, subcategoryId, technologyId } = options;
+    const constraints: QueryConstraint[] = [where("isActive", "==", true)];
+
+    if (categoryId) {
+      constraints.push(where("categoryId", "==", categoryId));
+    }
+    if (subcategoryId) {
+      constraints.push(where("subcategoryId", "==", subcategoryId));
+    }
+    if (technologyId) {
+      constraints.push(where("technologyId", "==", technologyId));
+    }
+
+    const q = query(
+      collectionGroup(this.db, PRODUCTS_COLLECTION),
+      ...constraints
+    );
+    const snapshot = await getCountFromServer(q);
+    return snapshot.data().count;
+  }
+
+  /**
+   * Gets counts of active products grouped by category, subcategory, and technology.
+   * This uses a single collectionGroup query for efficiency.
+   */
+  async getProductCounts(): Promise<{
+    byCategory: Record<string, number>;
+    bySubcategory: Record<string, number>;
+    byTechnology: Record<string, number>;
+  }> {
+    const q = query(
+      collectionGroup(this.db, PRODUCTS_COLLECTION),
+      where("isActive", "==", true)
+    );
+    const snapshot = await getDocs(q);
+
+    const counts = {
+      byCategory: {} as Record<string, number>,
+      bySubcategory: {} as Record<string, number>,
+      byTechnology: {} as Record<string, number>,
+    };
+
+    if (snapshot.empty) {
+      return counts;
+    }
+
+    snapshot.docs.forEach((doc) => {
+      const product = doc.data() as Product;
+      const { categoryId, subcategoryId, technologyId } = product;
+
+      if (categoryId) {
+        counts.byCategory[categoryId] =
+          (counts.byCategory[categoryId] || 0) + 1;
+      }
+      if (subcategoryId) {
+        counts.bySubcategory[subcategoryId] =
+          (counts.bySubcategory[subcategoryId] || 0) + 1;
+      }
+      if (technologyId) {
+        counts.byTechnology[technologyId] =
+          (counts.byTechnology[technologyId] || 0) + 1;
+      }
+    });
+
+    return counts;
   }
 
   /**

package/src/backoffice/services/requirement.service.ts

@@ -101,6 +101,19 @@ export class RequirementService extends BaseService {
     );
   }
 
+  /**
+   * Searches for requirements by name.
+   * @param name - The name to search for.
+   * @param type - The type of requirement (pre/post).
+   * @returns A list of requirements that match the search criteria.
+   */
+  async search(name: string, type: RequirementType) {
+    const requirements = await this.getAllByType(type);
+    return requirements.filter((r) =>
+      r.name.toLowerCase().includes(name.toLowerCase())
+    );
+  }
+
   /**
    * Ažurira postojeći zahtev
    * @param id - ID zahteva koji se ažurira

package/src/backoffice/services/subcategory.service.ts

@@ -1,10 +1,18 @@
 import {
   addDoc,
   collection,
+  collectionGroup,
+  deleteDoc,
   doc,
+  DocumentData,
+  getCountFromServer,
   getDoc,
   getDocs,
+  limit,
+  orderBy,
   query,
+  setDoc,
+  startAfter,
   updateDoc,
   where,
 } from "firebase/firestore";
@@ -69,17 +77,133 @@ export class SubcategoryService extends BaseService {
   }
 
   /**
-   * Vraća sve aktivne podkategorije za određenu kategoriju
+   * Returns counts of subcategories for all categories.
+   * @param active - Whether to count active or inactive subcategories.
+   * @returns A record mapping category ID to subcategory count.
+   */
+  async getSubcategoryCounts(active = true) {
+    const categoriesRef = collection(this.db, CATEGORIES_COLLECTION);
+    const categoriesSnapshot = await getDocs(categoriesRef);
+    const counts: Record<string, number> = {};
+
+    for (const categoryDoc of categoriesSnapshot.docs) {
+      const categoryId = categoryDoc.id;
+      const subcategoriesRef = this.getSubcategoriesRef(categoryId);
+      const q = query(subcategoriesRef, where("isActive", "==", active));
+      const snapshot = await getCountFromServer(q);
+      counts[categoryId] = snapshot.data().count;
+    }
+
+    return counts;
+  }
+
+  /**
+   * Vraća sve aktivne podkategorije za određenu kategoriju sa paginacijom
    * @param categoryId - ID kategorije čije podkategorije tražimo
-   * @returns Lista aktivnih podkategorija
+   * @param options - Pagination options
+   * @returns Lista aktivnih podkategorija i poslednji vidljiv dokument
    */
-  async getAllByCategoryId(categoryId: string) {
+  async getAllByCategoryId(
+    categoryId: string,
+    options: {
+      active?: boolean;
+      limit?: number;
+      lastVisible?: DocumentData;
+    } = {}
+  ) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where("isActive", "==", active),
+      orderBy("name"),
+      queryLimit ? limit(queryLimit) : undefined,
+      lastVisible ? startAfter(lastVisible) : undefined,
+    ].filter((c): c is NonNullable<typeof c> => !!c);
+
+    const q = query(this.getSubcategoriesRef(categoryId), ...constraints);
+
+    const querySnapshot = await getDocs(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Subcategory)
+    );
+    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
+    return { subcategories, lastVisible: newLastVisible };
+  }
+
+  /**
+   * Vraća sve podkategorije sa paginacijom koristeći collection group query.
+   * NOTE: This query requires a composite index in Firestore on the 'subcategories' collection group.
+   * The index should be on 'isActive' (ascending) and 'name' (ascending).
+   * Firestore will provide a link to create this index in the console error if it's missing.
+   * @param options - Pagination options
+   * @returns Lista podkategorija i poslednji vidljiv dokument
+   */
+  async getAll(
+    options: {
+      active?: boolean;
+      limit?: number;
+      lastVisible?: DocumentData;
+    } = {}
+  ) {
+    const { active = true, limit: queryLimit = 10, lastVisible } = options;
+    const constraints = [
+      where("isActive", "==", active),
+      orderBy("name"),
+      queryLimit ? limit(queryLimit) : undefined,
+      lastVisible ? startAfter(lastVisible) : undefined,
+    ].filter((c): c is NonNullable<typeof c> => !!c);
+
+    const q = query(
+      collectionGroup(this.db, SUBCATEGORIES_COLLECTION),
+      ...constraints
+    );
+
+    const querySnapshot = await getDocs(q);
+    const subcategories = querySnapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Subcategory)
+    );
+    const newLastVisible = querySnapshot.docs[querySnapshot.docs.length - 1];
+    return { subcategories, lastVisible: newLastVisible };
+  }
+
+  /**
+   * Vraća sve subkategorije za određenu kategoriju za potrebe filtera (bez paginacije)
+   * @param categoryId - ID kategorije čije subkategorije tražimo
+   * @returns Lista svih aktivnih subkategorija
+   */
+  async getAllForFilterByCategoryId(categoryId: string) {
     const q = query(
       this.getSubcategoriesRef(categoryId),
       where("isActive", "==", true)
     );
-    const snapshot = await getDocs(q);
-    return snapshot.docs.map(
+    const querySnapshot = await getDocs(q);
+    return querySnapshot.docs.map(
+      (doc) =>
+        ({
+          id: doc.id,
+          ...doc.data(),
+        } as Subcategory)
+    );
+  }
+
+  /**
+   * Vraća sve subkategorije za potrebe filtera (bez paginacije)
+   * @returns Lista svih aktivnih subkategorija
+   */
+  async getAllForFilter() {
+    const q = query(
+      collectionGroup(this.db, SUBCATEGORIES_COLLECTION),
+      where("isActive", "==", true)
+    );
+    const querySnapshot = await getDocs(q);
+    return querySnapshot.docs.map(
       (doc) =>
         ({
           id: doc.id,
@@ -98,16 +222,54 @@ export class SubcategoryService extends BaseService {
   async update(
     categoryId: string,
     subcategoryId: string,
-    subcategory: Partial<Omit<Subcategory, "id" | "createdAt" | "categoryId">>
+    subcategory: Partial<Omit<Subcategory, "id" | "createdAt">>
   ) {
-    const updateData = {
-      ...subcategory,
-      updatedAt: new Date(),
-    };
+    const newCategoryId = subcategory.categoryId;
 
-    const docRef = doc(this.getSubcategoriesRef(categoryId), subcategoryId);
-    await updateDoc(docRef, updateData);
-    return this.getById(categoryId, subcategoryId);
+    if (newCategoryId && newCategoryId !== categoryId) {
+      // Category has changed, move the document
+      const oldDocRef = doc(
+        this.getSubcategoriesRef(categoryId),
+        subcategoryId
+      );
+      const docSnap = await getDoc(oldDocRef);
+
+      if (!docSnap.exists()) {
+        throw new Error("Subcategory to update does not exist.");
+      }
+
+      const existingData = docSnap.data();
+      const newData: Omit<Subcategory, "id"> = {
+        ...(existingData as Omit<
+          Subcategory,
+          "id" | "createdAt" | "updatedAt"
+        >),
+        ...subcategory,
+        categoryId: newCategoryId, // Ensure categoryId is updated
+        createdAt: existingData.createdAt, // Preserve original creation date
+        updatedAt: new Date(),
+      };
+
+      const newDocRef = doc(
+        this.getSubcategoriesRef(newCategoryId),
+        subcategoryId
+      );
+
+      await setDoc(newDocRef, newData);
+      await deleteDoc(oldDocRef);
+
+      return { id: subcategoryId, ...newData };
+    } else {
+      // Category has not changed, just update the document
+      const updateData = {
+        ...subcategory,
+        updatedAt: new Date(),
+      };
+
+      const docRef = doc(this.getSubcategoriesRef(categoryId), subcategoryId);
+      await updateDoc(docRef, updateData);
+      return this.getById(categoryId, subcategoryId);
+    }
   }
 
   /**
@@ -119,6 +281,15 @@ export class SubcategoryService extends BaseService {
     await this.update(categoryId, subcategoryId, { isActive: false });
   }
 
+  /**
+   * Reactivates a subcategory by setting its isActive flag to true.
+   * @param categoryId - The ID of the category to which the subcategory belongs.
+   * @param subcategoryId - The ID of the subcategory to reactivate.
+   */
+  async reactivate(categoryId: string, subcategoryId: string) {
+    await this.update(categoryId, subcategoryId, { isActive: true });
+  }
+
   /**
    * Vraća podkategoriju po ID-u
    * @param categoryId - ID kategorije kojoj pripada podkategorija