@blackcode_sa/metaestetics-api 1.12.62 → 1.12.64

package/dist/backoffice/index.js

@@ -53,6 +53,8 @@ __export(index_exports, {
   InvalidTimeframeError: () => InvalidTimeframeError,
   InvalidTreatmentBenefitError: () => InvalidTreatmentBenefitError,
   ListType: () => ListType,
+  MediaAccessLevel: () => MediaAccessLevel,
+  MediaService: () => MediaService,
   PRODUCTS_COLLECTION: () => PRODUCTS_COLLECTION,
   PricingMeasure: () => PricingMeasure,
   ProcedureFamily: () => ProcedureFamily,
@@ -1185,6 +1187,299 @@ var import_firestore7 = require("firebase/firestore");
 var import_firestore5 = require("firebase/firestore");
 var import_storage2 = require("firebase/storage");
 var import_firestore6 = require("firebase/firestore");
+var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
+  MediaAccessLevel2["PUBLIC"] = "public";
+  MediaAccessLevel2["PRIVATE"] = "private";
+  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
+  return MediaAccessLevel2;
+})(MediaAccessLevel || {});
+var MEDIA_METADATA_COLLECTION = "media_metadata";
+var MediaService = class extends BaseService {
+  constructor(...args) {
+    super(...args);
+  }
+  /**
+   * Upload a media file, store its metadata, and return the metadata including the URL.
+   * @param file - The file to upload.
+   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
+   * @param accessLevel - Access level (public, private, confidential).
+   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
+   * @param originalFileName - Optional: the original name of the file, if not using file.name.
+   * @returns Promise with the media metadata.
+   */
+  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
+    const mediaId = this.generateId();
+    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
+    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
+    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
+    console.log(`[MediaService] Uploading file to: ${filePath}`);
+    const storageRef = (0, import_storage2.ref)(this.storage, filePath);
+    try {
+      const uploadResult = await (0, import_storage2.uploadBytes)(storageRef, file, {
+        contentType: file.type
+      });
+      console.log("[MediaService] File uploaded successfully", uploadResult);
+      const downloadURL = await (0, import_storage2.getDownloadURL)(uploadResult.ref);
+      console.log("[MediaService] Got download URL:", downloadURL);
+      const metadata = {
+        id: mediaId,
+        name: fileNameToUse,
+        url: downloadURL,
+        contentType: file.type,
+        size: file.size,
+        createdAt: import_firestore5.Timestamp.now(),
+        accessLevel,
+        ownerId,
+        collectionName,
+        path: filePath
+      };
+      const metadataDocRef = (0, import_firestore6.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore6.setDoc)(metadataDocRef, metadata);
+      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
+      return metadata;
+    } catch (error) {
+      console.error("[MediaService] Error during media upload:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get media metadata from Firestore by its ID.
+   * @param mediaId - ID of the media.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadata(mediaId) {
+    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
+    const docRef = (0, import_firestore6.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await (0, import_firestore6.getDoc)(docRef);
+    if (docSnap.exists()) {
+      console.log("[MediaService] Metadata found:", docSnap.data());
+      return docSnap.data();
+    }
+    console.log("[MediaService] No metadata found for ID:", mediaId);
+    return null;
+  }
+  /**
+   * Get media metadata from Firestore by its public URL.
+   * @param url - The public URL of the media file.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadataByUrl(url) {
+    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
+    const q = (0, import_firestore6.query)(
+      (0, import_firestore6.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      (0, import_firestore6.where)("url", "==", url),
+      (0, import_firestore6.limit)(1)
+    );
+    try {
+      const querySnapshot = await (0, import_firestore6.getDocs)(q);
+      if (!querySnapshot.empty) {
+        const metadata = querySnapshot.docs[0].data();
+        console.log("[MediaService] Metadata found by URL:", metadata);
+        return metadata;
+      }
+      console.log("[MediaService] No metadata found for URL:", url);
+      return null;
+    } catch (error) {
+      console.error("[MediaService] Error fetching metadata by URL:", error);
+      throw error;
+    }
+  }
+  /**
+   * Delete media from storage and remove metadata from Firestore.
+   * @param mediaId - ID of the media to delete.
+   */
+  async deleteMedia(mediaId) {
+    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
+      );
+      return;
+    }
+    const storageFileRef = (0, import_storage2.ref)(this.storage, metadata.path);
+    try {
+      await (0, import_storage2.deleteObject)(storageFileRef);
+      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
+      const metadataDocRef = (0, import_firestore6.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await (0, import_firestore6.deleteDoc)(metadataDocRef);
+      console.log(
+        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
+      );
+    } catch (error) {
+      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Update media access level. This involves moving the file in Firebase Storage
+   * to a new path reflecting the new access level, and updating its metadata.
+   * @param mediaId - ID of the media to update.
+   * @param newAccessLevel - New access level.
+   * @returns Promise with the updated media metadata, or null if metadata not found.
+   */
+  async updateMediaAccessLevel(mediaId, newAccessLevel) {
+    var _a;
+    console.log(
+      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
+    );
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
+      );
+      return null;
+    }
+    if (metadata.accessLevel === newAccessLevel) {
+      console.log(
+        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
+      );
+      const metadataDocRef = (0, import_firestore6.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      try {
+        await (0, import_firestore6.updateDoc)(metadataDocRef, { updatedAt: import_firestore5.Timestamp.now() });
+        return { ...metadata, updatedAt: import_firestore5.Timestamp.now() };
+      } catch (error) {
+        console.error(
+          `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    const oldStoragePath = metadata.path;
+    const fileNamePart = `${metadata.id}-${metadata.name}`;
+    const newStoragePath = `media/${newAccessLevel}/${metadata.ownerId}/${metadata.collectionName}/${fileNamePart}`;
+    console.log(
+      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
+    );
+    const oldStorageFileRef = (0, import_storage2.ref)(this.storage, oldStoragePath);
+    const newStorageFileRef = (0, import_storage2.ref)(this.storage, newStoragePath);
+    try {
+      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
+      const fileBytes = await (0, import_storage2.getBytes)(oldStorageFileRef);
+      console.log(
+        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
+      );
+      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
+      await (0, import_storage2.uploadBytes)(newStorageFileRef, fileBytes, {
+        contentType: metadata.contentType
+      });
+      console.log(
+        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
+      );
+      const newDownloadURL = await (0, import_storage2.getDownloadURL)(newStorageFileRef);
+      console.log(
+        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
+      );
+      const updateData = {
+        accessLevel: newAccessLevel,
+        path: newStoragePath,
+        url: newDownloadURL,
+        updatedAt: import_firestore5.Timestamp.now()
+      };
+      const metadataDocRef = (0, import_firestore6.doc)(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      console.log(
+        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
+        updateData
+      );
+      await (0, import_firestore6.updateDoc)(metadataDocRef, updateData);
+      console.log(
+        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
+      );
+      try {
+        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
+        await (0, import_storage2.deleteObject)(oldStorageFileRef);
+        console.log(
+          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
+        );
+      } catch (deleteError) {
+        console.error(
+          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
+          deleteError
+        );
+      }
+      return { ...metadata, ...updateData };
+    } catch (error) {
+      console.error(
+        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
+        error
+      );
+      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
+        console.warn(
+          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
+        );
+        try {
+          await (0, import_storage2.deleteObject)(newStorageFileRef);
+          console.warn(
+            `[MediaService] Cleaned up partially uploaded file at ${newStoragePath}.`
+          );
+        } catch (cleanupError) {
+          console.error(
+            `[MediaService] Failed to cleanup partially uploaded file at ${newStoragePath}:`,
+            cleanupError
+          );
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all media for an owner, optionally filtered by collection and access level.
+   * @param ownerId - ID of the owner.
+   * @param collectionName - Optional: Filter by collection name.
+   * @param accessLevel - Optional: Filter by access level.
+   * @param count - Optional: Number of items to fetch.
+   * @param startAfterId - Optional: ID of the document to start after (for pagination).
+   */
+  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
+    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
+    let qConstraints = [(0, import_firestore6.where)("ownerId", "==", ownerId)];
+    if (collectionName) {
+      qConstraints.push((0, import_firestore6.where)("collectionName", "==", collectionName));
+    }
+    if (accessLevel) {
+      qConstraints.push((0, import_firestore6.where)("accessLevel", "==", accessLevel));
+    }
+    qConstraints.push((0, import_firestore6.orderBy)("createdAt", "desc"));
+    if (count) {
+      qConstraints.push((0, import_firestore6.limit)(count));
+    }
+    if (startAfterId) {
+      const startAfterDoc = await this.getMediaMetadata(startAfterId);
+      if (startAfterDoc) {
+      }
+    }
+    const finalQuery = (0, import_firestore6.query)(
+      (0, import_firestore6.collection)(this.db, MEDIA_METADATA_COLLECTION),
+      ...qConstraints
+    );
+    try {
+      const querySnapshot = await (0, import_firestore6.getDocs)(finalQuery);
+      const mediaList = querySnapshot.docs.map(
+        (doc11) => doc11.data()
+      );
+      console.log(`[MediaService] Found ${mediaList.length} media items.`);
+      return mediaList;
+    } catch (error) {
+      console.error("[MediaService] Error listing media:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get download URL for media. (Convenience, as URL is in metadata)
+   * @param mediaId - ID of the media.
+   */
+  async getMediaDownloadUrl(mediaId) {
+    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (metadata && metadata.url) {
+      console.log(`[MediaService] URL found: ${metadata.url}`);
+      return metadata.url;
+    }
+    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
+    return null;
+  }
+};
 
 // src/backoffice/services/documentation-template.service.ts
 var DocumentationTemplateServiceBackoffice = class {
@@ -2285,6 +2580,9 @@ var TechnologyService = class extends BaseService {
     if (technology.technicalDetails) {
       newTechnology.technicalDetails = technology.technicalDetails;
     }
+    if (technology.photoTemplate) {
+      newTechnology.photoTemplate = technology.photoTemplate;
+    }
     const docRef = await (0, import_firestore11.addDoc)(this.technologiesRef, newTechnology);
     return { id: docRef.id, ...newTechnology };
   }
@@ -2407,6 +2705,13 @@ var TechnologyService = class extends BaseService {
         delete updateData[key];
       }
     });
+    if ("photoTemplate" in technology) {
+      if (technology.photoTemplate === null || technology.photoTemplate === "") {
+        updateData.photoTemplate = null;
+      } else if (technology.photoTemplate !== void 0) {
+        updateData.photoTemplate = technology.photoTemplate;
+      }
+    }
     updateData.updatedAt = /* @__PURE__ */ new Date();
     const docRef = (0, import_firestore11.doc)(this.technologiesRef, id);
     const beforeTech = await this.getById(id);
@@ -3510,6 +3815,7 @@ var technologySchema = import_zod2.z.object({
   documentationTemplates: import_zod2.z.array(documentTemplateSchema),
   benefits: import_zod2.z.array(treatmentBenefitSchemaBackoffice),
   certificationRequirement: certificationRequirementSchema,
+  photoTemplate: import_zod2.z.string().url("Photo template must be a valid URL").optional(),
   isActive: import_zod2.z.boolean().default(true)
 });
 var categorySchema = import_zod2.z.object({
@@ -3709,6 +4015,8 @@ var InvalidTreatmentBenefitError = class extends TreatmentBenefitError {
   InvalidTimeframeError,
   InvalidTreatmentBenefitError,
   ListType,
+  MediaAccessLevel,
+  MediaService,
   PRODUCTS_COLLECTION,
   PricingMeasure,
   ProcedureFamily,

package/dist/backoffice/index.mjs

@@ -1148,6 +1148,299 @@ import {
   deleteDoc as deleteDoc2,
   orderBy as orderBy4
 } from "firebase/firestore";
+var MediaAccessLevel = /* @__PURE__ */ ((MediaAccessLevel2) => {
+  MediaAccessLevel2["PUBLIC"] = "public";
+  MediaAccessLevel2["PRIVATE"] = "private";
+  MediaAccessLevel2["CONFIDENTIAL"] = "confidential";
+  return MediaAccessLevel2;
+})(MediaAccessLevel || {});
+var MEDIA_METADATA_COLLECTION = "media_metadata";
+var MediaService = class extends BaseService {
+  constructor(...args) {
+    super(...args);
+  }
+  /**
+   * Upload a media file, store its metadata, and return the metadata including the URL.
+   * @param file - The file to upload.
+   * @param ownerId - ID of the owner (user, patient, clinic, etc.).
+   * @param accessLevel - Access level (public, private, confidential).
+   * @param collectionName - The logical collection name this media belongs to (e.g., 'patient_profile_pictures', 'clinic_logos').
+   * @param originalFileName - Optional: the original name of the file, if not using file.name.
+   * @returns Promise with the media metadata.
+   */
+  async uploadMedia(file, ownerId, accessLevel, collectionName, originalFileName) {
+    const mediaId = this.generateId();
+    const fileNameToUse = originalFileName || (file instanceof File ? file.name : file.toString());
+    const uniqueFileName = `${mediaId}-${fileNameToUse}`;
+    const filePath = `media/${accessLevel}/${ownerId}/${collectionName}/${uniqueFileName}`;
+    console.log(`[MediaService] Uploading file to: ${filePath}`);
+    const storageRef = ref(this.storage, filePath);
+    try {
+      const uploadResult = await uploadBytes(storageRef, file, {
+        contentType: file.type
+      });
+      console.log("[MediaService] File uploaded successfully", uploadResult);
+      const downloadURL = await getDownloadURL(uploadResult.ref);
+      console.log("[MediaService] Got download URL:", downloadURL);
+      const metadata = {
+        id: mediaId,
+        name: fileNameToUse,
+        url: downloadURL,
+        contentType: file.type,
+        size: file.size,
+        createdAt: Timestamp2.now(),
+        accessLevel,
+        ownerId,
+        collectionName,
+        path: filePath
+      };
+      const metadataDocRef = doc4(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await setDoc2(metadataDocRef, metadata);
+      console.log("[MediaService] Metadata stored in Firestore:", mediaId);
+      return metadata;
+    } catch (error) {
+      console.error("[MediaService] Error during media upload:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get media metadata from Firestore by its ID.
+   * @param mediaId - ID of the media.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadata(mediaId) {
+    console.log(`[MediaService] Getting media metadata for ID: ${mediaId}`);
+    const docRef = doc4(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+    const docSnap = await getDoc4(docRef);
+    if (docSnap.exists()) {
+      console.log("[MediaService] Metadata found:", docSnap.data());
+      return docSnap.data();
+    }
+    console.log("[MediaService] No metadata found for ID:", mediaId);
+    return null;
+  }
+  /**
+   * Get media metadata from Firestore by its public URL.
+   * @param url - The public URL of the media file.
+   * @returns Promise with the media metadata or null if not found.
+   */
+  async getMediaMetadataByUrl(url) {
+    console.log(`[MediaService] Getting media metadata by URL: ${url}`);
+    const q = query4(
+      collection4(this.db, MEDIA_METADATA_COLLECTION),
+      where4("url", "==", url),
+      limit4(1)
+    );
+    try {
+      const querySnapshot = await getDocs4(q);
+      if (!querySnapshot.empty) {
+        const metadata = querySnapshot.docs[0].data();
+        console.log("[MediaService] Metadata found by URL:", metadata);
+        return metadata;
+      }
+      console.log("[MediaService] No metadata found for URL:", url);
+      return null;
+    } catch (error) {
+      console.error("[MediaService] Error fetching metadata by URL:", error);
+      throw error;
+    }
+  }
+  /**
+   * Delete media from storage and remove metadata from Firestore.
+   * @param mediaId - ID of the media to delete.
+   */
+  async deleteMedia(mediaId) {
+    console.log(`[MediaService] Deleting media with ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot delete.`
+      );
+      return;
+    }
+    const storageFileRef = ref(this.storage, metadata.path);
+    try {
+      await deleteObject(storageFileRef);
+      console.log(`[MediaService] File deleted from Storage: ${metadata.path}`);
+      const metadataDocRef = doc4(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      await deleteDoc2(metadataDocRef);
+      console.log(
+        `[MediaService] Metadata deleted from Firestore for ID: ${mediaId}`
+      );
+    } catch (error) {
+      console.error(`[MediaService] Error deleting media ${mediaId}:`, error);
+      throw error;
+    }
+  }
+  /**
+   * Update media access level. This involves moving the file in Firebase Storage
+   * to a new path reflecting the new access level, and updating its metadata.
+   * @param mediaId - ID of the media to update.
+   * @param newAccessLevel - New access level.
+   * @returns Promise with the updated media metadata, or null if metadata not found.
+   */
+  async updateMediaAccessLevel(mediaId, newAccessLevel) {
+    var _a;
+    console.log(
+      `[MediaService] Attempting to update access level for media ID: ${mediaId} to ${newAccessLevel}`
+    );
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (!metadata) {
+      console.warn(
+        `[MediaService] Metadata not found for media ID ${mediaId}. Cannot update access level.`
+      );
+      return null;
+    }
+    if (metadata.accessLevel === newAccessLevel) {
+      console.log(
+        `[MediaService] Media ID ${mediaId} already has access level ${newAccessLevel}. Updating timestamp only.`
+      );
+      const metadataDocRef = doc4(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      try {
+        await updateDoc4(metadataDocRef, { updatedAt: Timestamp2.now() });
+        return { ...metadata, updatedAt: Timestamp2.now() };
+      } catch (error) {
+        console.error(
+          `[MediaService] Error updating timestamp for media ID ${mediaId}:`,
+          error
+        );
+        throw error;
+      }
+    }
+    const oldStoragePath = metadata.path;
+    const fileNamePart = `${metadata.id}-${metadata.name}`;
+    const newStoragePath = `media/${newAccessLevel}/${metadata.ownerId}/${metadata.collectionName}/${fileNamePart}`;
+    console.log(
+      `[MediaService] Moving file for ${mediaId} from ${oldStoragePath} to ${newStoragePath}`
+    );
+    const oldStorageFileRef = ref(this.storage, oldStoragePath);
+    const newStorageFileRef = ref(this.storage, newStoragePath);
+    try {
+      console.log(`[MediaService] Downloading bytes from ${oldStoragePath}`);
+      const fileBytes = await getBytes(oldStorageFileRef);
+      console.log(
+        `[MediaService] Successfully downloaded ${fileBytes.byteLength} bytes from ${oldStoragePath}`
+      );
+      console.log(`[MediaService] Uploading bytes to ${newStoragePath}`);
+      await uploadBytes(newStorageFileRef, fileBytes, {
+        contentType: metadata.contentType
+      });
+      console.log(
+        `[MediaService] Successfully uploaded bytes to ${newStoragePath}`
+      );
+      const newDownloadURL = await getDownloadURL(newStorageFileRef);
+      console.log(
+        `[MediaService] Got new download URL for ${newStoragePath}: ${newDownloadURL}`
+      );
+      const updateData = {
+        accessLevel: newAccessLevel,
+        path: newStoragePath,
+        url: newDownloadURL,
+        updatedAt: Timestamp2.now()
+      };
+      const metadataDocRef = doc4(this.db, MEDIA_METADATA_COLLECTION, mediaId);
+      console.log(
+        `[MediaService] Updating Firestore metadata for ${mediaId} with new data:`,
+        updateData
+      );
+      await updateDoc4(metadataDocRef, updateData);
+      console.log(
+        `[MediaService] Successfully updated Firestore metadata for ${mediaId}`
+      );
+      try {
+        console.log(`[MediaService] Deleting old file from ${oldStoragePath}`);
+        await deleteObject(oldStorageFileRef);
+        console.log(
+          `[MediaService] Successfully deleted old file from ${oldStoragePath}`
+        );
+      } catch (deleteError) {
+        console.error(
+          `[MediaService] Failed to delete old file from ${oldStoragePath} for media ID ${mediaId}. This file is now orphaned. Error:`,
+          deleteError
+        );
+      }
+      return { ...metadata, ...updateData };
+    } catch (error) {
+      console.error(
+        `[MediaService] Error updating media access level and moving file for ${mediaId}:`,
+        error
+      );
+      if (newStorageFileRef && error.code !== "storage/object-not-found" && ((_a = error.message) == null ? void 0 : _a.includes("uploadBytes"))) {
+        console.warn(
+          `[MediaService] Attempting to delete partially uploaded file at ${newStoragePath} due to error.`
+        );
+        try {
+          await deleteObject(newStorageFileRef);
+          console.warn(
+            `[MediaService] Cleaned up partially uploaded file at ${newStoragePath}.`
+          );
+        } catch (cleanupError) {
+          console.error(
+            `[MediaService] Failed to cleanup partially uploaded file at ${newStoragePath}:`,
+            cleanupError
+          );
+        }
+      }
+      throw error;
+    }
+  }
+  /**
+   * List all media for an owner, optionally filtered by collection and access level.
+   * @param ownerId - ID of the owner.
+   * @param collectionName - Optional: Filter by collection name.
+   * @param accessLevel - Optional: Filter by access level.
+   * @param count - Optional: Number of items to fetch.
+   * @param startAfterId - Optional: ID of the document to start after (for pagination).
+   */
+  async listMedia(ownerId, collectionName, accessLevel, count, startAfterId) {
+    console.log(`[MediaService] Listing media for owner: ${ownerId}`);
+    let qConstraints = [where4("ownerId", "==", ownerId)];
+    if (collectionName) {
+      qConstraints.push(where4("collectionName", "==", collectionName));
+    }
+    if (accessLevel) {
+      qConstraints.push(where4("accessLevel", "==", accessLevel));
+    }
+    qConstraints.push(orderBy4("createdAt", "desc"));
+    if (count) {
+      qConstraints.push(limit4(count));
+    }
+    if (startAfterId) {
+      const startAfterDoc = await this.getMediaMetadata(startAfterId);
+      if (startAfterDoc) {
+      }
+    }
+    const finalQuery = query4(
+      collection4(this.db, MEDIA_METADATA_COLLECTION),
+      ...qConstraints
+    );
+    try {
+      const querySnapshot = await getDocs4(finalQuery);
+      const mediaList = querySnapshot.docs.map(
+        (doc11) => doc11.data()
+      );
+      console.log(`[MediaService] Found ${mediaList.length} media items.`);
+      return mediaList;
+    } catch (error) {
+      console.error("[MediaService] Error listing media:", error);
+      throw error;
+    }
+  }
+  /**
+   * Get download URL for media. (Convenience, as URL is in metadata)
+   * @param mediaId - ID of the media.
+   */
+  async getMediaDownloadUrl(mediaId) {
+    console.log(`[MediaService] Getting download URL for media ID: ${mediaId}`);
+    const metadata = await this.getMediaMetadata(mediaId);
+    if (metadata && metadata.url) {
+      console.log(`[MediaService] URL found: ${metadata.url}`);
+      return metadata.url;
+    }
+    console.log(`[MediaService] URL not found for media ID: ${mediaId}`);
+    return null;
+  }
+};
 
 // src/backoffice/services/documentation-template.service.ts
 var DocumentationTemplateServiceBackoffice = class {
@@ -2305,6 +2598,9 @@ var TechnologyService = class extends BaseService {
     if (technology.technicalDetails) {
       newTechnology.technicalDetails = technology.technicalDetails;
     }
+    if (technology.photoTemplate) {
+      newTechnology.photoTemplate = technology.photoTemplate;
+    }
     const docRef = await addDoc6(this.technologiesRef, newTechnology);
     return { id: docRef.id, ...newTechnology };
   }
@@ -2427,6 +2723,13 @@ var TechnologyService = class extends BaseService {
         delete updateData[key];
       }
     });
+    if ("photoTemplate" in technology) {
+      if (technology.photoTemplate === null || technology.photoTemplate === "") {
+        updateData.photoTemplate = null;
+      } else if (technology.photoTemplate !== void 0) {
+        updateData.photoTemplate = technology.photoTemplate;
+      }
+    }
     updateData.updatedAt = /* @__PURE__ */ new Date();
     const docRef = doc9(this.technologiesRef, id);
     const beforeTech = await this.getById(id);
@@ -3537,6 +3840,7 @@ var technologySchema = z2.object({
   documentationTemplates: z2.array(documentTemplateSchema),
   benefits: z2.array(treatmentBenefitSchemaBackoffice),
   certificationRequirement: certificationRequirementSchema,
+  photoTemplate: z2.string().url("Photo template must be a valid URL").optional(),
   isActive: z2.boolean().default(true)
 });
 var categorySchema = z2.object({
@@ -3735,6 +4039,8 @@ export {
   InvalidTimeframeError,
   InvalidTreatmentBenefitError,
   ListType,
+  MediaAccessLevel,
+  MediaService,
   PRODUCTS_COLLECTION,
   PricingMeasure,
   ProcedureFamily,