@blackcode_sa/metaestetics-api 1.12.2 → 1.12.4

package/src/backoffice/types/technology.types.ts

@@ -1,10 +1,10 @@
-import { Requirement } from "./requirement.types";
-import { BlockingCondition } from "./static/blocking-condition.types";
-import { CertificationRequirement } from "./static/certification.types";
-import { DocumentTemplate } from "../../types/documentation-templates";
-import { ProcedureFamily } from "./static/procedure-family.types";
-import { ContraindicationDynamic } from "./admin-constants.types";
-import { TreatmentBenefitDynamic } from "./admin-constants.types";
+import { Requirement } from './requirement.types';
+import { BlockingCondition } from './static/blocking-condition.types';
+import { CertificationRequirement } from './static/certification.types';
+import { DocumentTemplate } from '../../types/documentation-templates';
+import { ProcedureFamily } from './static/procedure-family.types';
+import { ContraindicationDynamic } from './admin-constants.types';
+import { TreatmentBenefitDynamic } from './admin-constants.types';
 
 /**
  * Reference to a documentation template with metadata
@@ -77,19 +77,15 @@ export interface Technology {
 /**
  * Collection in Firestore database where technologies are stored
  */
-export const TECHNOLOGIES_COLLECTION = "technologies";
+export const TECHNOLOGIES_COLLECTION = 'technologies';
 
 /**
  * Interface for the TechnologyService class
  */
 export interface ITechnologyService {
-  create(
-    technology: Omit<Technology, "id" | "createdAt" | "updatedAt">
-  ): Promise<Technology>;
+  create(technology: Omit<Technology, 'id' | 'createdAt' | 'updatedAt'>): Promise<Technology>;
   getTechnologyCounts(active?: boolean): Promise<Record<string, number>>;
-  getTechnologyCountsByCategory(
-    active?: boolean
-  ): Promise<Record<string, number>>;
+  getTechnologyCountsByCategory(active?: boolean): Promise<Record<string, number>>;
   getAll(options?: {
     active?: boolean;
     limit?: number;
@@ -97,83 +93,61 @@ export interface ITechnologyService {
   }): Promise<{ technologies: Technology[]; lastVisible: any }>;
   getAllByCategoryId(
     categoryId: string,
-    options?: { active?: boolean; limit?: number; lastVisible?: any }
+    options?: { active?: boolean; limit?: number; lastVisible?: any },
   ): Promise<{ technologies: Technology[]; lastVisible: any }>;
   getAllBySubcategoryId(
     subcategoryId: string,
-    options?: { active?: boolean; limit?: number; lastVisible?: any }
+    options?: { active?: boolean; limit?: number; lastVisible?: any },
   ): Promise<{ technologies: Technology[]; lastVisible: any }>;
   update(
     id: string,
-    technology: Partial<Omit<Technology, "id" | "createdAt">>
+    technology: Partial<Omit<Technology, 'id' | 'createdAt'>>,
   ): Promise<Technology | null>;
   delete(id: string): Promise<void>;
   reactivate(id: string): Promise<void>;
   getById(id: string): Promise<Technology | null>;
-  addRequirement(
-    technologyId: string,
-    requirement: Requirement
-  ): Promise<Technology | null>;
-  removeRequirement(
-    technologyId: string,
-    requirement: Requirement
-  ): Promise<Technology | null>;
-  getRequirements(
-    technologyId: string,
-    type?: "pre" | "post"
-  ): Promise<Requirement[]>;
+  addRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
+  removeRequirement(technologyId: string, requirement: Requirement): Promise<Technology | null>;
+  getRequirements(technologyId: string, type?: 'pre' | 'post'): Promise<Requirement[]>;
   updateRequirement(
     technologyId: string,
     oldRequirement: Requirement,
-    newRequirement: Requirement
+    newRequirement: Requirement,
   ): Promise<Technology | null>;
   addBlockingCondition(
     technologyId: string,
-    condition: BlockingCondition
+    condition: BlockingCondition,
   ): Promise<Technology | null>;
   removeBlockingCondition(
     technologyId: string,
-    condition: BlockingCondition
+    condition: BlockingCondition,
   ): Promise<Technology | null>;
   addContraindication(
     technologyId: string,
-    contraindication: ContraindicationDynamic
+    contraindication: ContraindicationDynamic,
   ): Promise<Technology | null>;
   removeContraindication(
     technologyId: string,
-    contraindication: ContraindicationDynamic
+    contraindication: ContraindicationDynamic,
   ): Promise<Technology | null>;
   updateContraindication(
     technologyId: string,
-    contraindication: ContraindicationDynamic
-  ): Promise<Technology | null>;
-  addBenefit(
-    technologyId: string,
-    benefit: TreatmentBenefitDynamic
-  ): Promise<Technology | null>;
-  removeBenefit(
-    technologyId: string,
-    benefit: TreatmentBenefitDynamic
-  ): Promise<Technology | null>;
-  updateBenefit(
-    technologyId: string,
-    benefit: TreatmentBenefitDynamic
+    contraindication: ContraindicationDynamic,
   ): Promise<Technology | null>;
+  addBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
+  removeBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
+  updateBenefit(technologyId: string, benefit: TreatmentBenefitDynamic): Promise<Technology | null>;
   getBlockingConditions(technologyId: string): Promise<BlockingCondition[]>;
-  getContraindications(
-    technologyId: string
-  ): Promise<ContraindicationDynamic[]>;
+  getContraindications(technologyId: string): Promise<ContraindicationDynamic[]>;
   getBenefits(technologyId: string): Promise<TreatmentBenefitDynamic[]>;
   updateCertificationRequirement(
     technologyId: string,
-    certificationRequirement: CertificationRequirement
+    certificationRequirement: CertificationRequirement,
   ): Promise<Technology | null>;
-  getCertificationRequirement(
-    technologyId: string
-  ): Promise<CertificationRequirement | null>;
+  getCertificationRequirement(technologyId: string): Promise<CertificationRequirement | null>;
   validateCertification(
     requiredCertification: CertificationRequirement,
-    practitionerCertification: any
+    practitionerCertification: any,
   ): boolean;
   getAllowedTechnologies(practitioner: any): Promise<{
     technologies: Technology[];
@@ -181,9 +155,7 @@ export interface ITechnologyService {
     categories: string[];
     subcategories: string[];
   }>;
-  getAllForFilterBySubcategoryId(
-    categoryId: string,
-    subcategoryId: string
-  ): Promise<Technology[]>;
+  getAllForFilterBySubcategory(subcategoryId: string): Promise<Technology[]>;
+  getAllForFilterBySubcategoryId(categoryId: string, subcategoryId: string): Promise<Technology[]>;
   getAllForFilter(): Promise<Technology[]>;
 }

package/src/types/clinic/index.ts

@@ -174,6 +174,93 @@ export enum SubscriptionModel {
   ENTERPRISE = "enterprise",
 }
 
+/**
+ * Enum for subscription status
+ */
+export enum SubscriptionStatus {
+  ACTIVE = "active",
+  PENDING_CANCELLATION = "pending_cancellation",
+  CANCELED = "canceled",
+  PAST_DUE = "past_due",
+  TRIALING = "trialing",
+}
+
+/**
+ * Interface for billing information
+ */
+export interface BillingInfo {
+  stripeCustomerId: string;
+  subscriptionStatus: SubscriptionStatus;
+  planType: string;
+  stripeSubscriptionId: string | null;
+  stripePriceId: string | null;
+  currentPeriodStart: Timestamp | null;
+  currentPeriodEnd: Timestamp | null;
+  updatedAt: Timestamp;
+}
+
+/**
+ * Enum for billing transaction types
+ */
+export enum BillingTransactionType {
+  SUBSCRIPTION_ACTIVATED = "subscription_activated",
+  SUBSCRIPTION_RENEWED = "subscription_renewed",
+  SUBSCRIPTION_UPDATED = "subscription_updated",
+  SUBSCRIPTION_CANCELED = "subscription_canceled",
+  SUBSCRIPTION_REACTIVATED = "subscription_reactivated",
+  SUBSCRIPTION_DELETED = "subscription_deleted",
+}
+
+/**
+ * Interface for Stripe data in billing transactions
+ */
+export interface StripeTransactionData {
+  sessionId?: string;
+  subscriptionId?: string;
+  invoiceId?: string;
+  priceId: string;
+  customerId: string;
+}
+
+/**
+ * Interface for plan details in billing transactions
+ */
+export interface PlanDetails {
+  planName: string;
+  planPeriod: string;
+  planDisplayName: string;
+}
+
+/**
+ * Interface for billing transactions
+ */
+export interface BillingTransaction {
+  id: string;
+  clinicGroupId: string;
+  type: BillingTransactionType;
+  description: string;
+  amount: number;
+  currency: string;
+  stripeData: StripeTransactionData;
+  planDetails: PlanDetails;
+  metadata?: Record<string, any>;
+  timestamp: Timestamp;
+  createdAt: Timestamp;
+}
+
+/**
+ * Interface for creating a billing transaction
+ */
+export interface CreateBillingTransactionData {
+  type: BillingTransactionType;
+  description: string;
+  amount: number;
+  currency: string;
+  stripeData: StripeTransactionData;
+  planDetails: PlanDetails;
+  metadata?: Record<string, any>;
+}
+
 /**
  * Interface for clinic group
  */
@@ -197,6 +284,7 @@ export interface ClinicGroup {
   practiceType?: PracticeType;
   languages?: Language[];
   subscriptionModel: SubscriptionModel;
+  billing?: BillingInfo;
   calendarSyncEnabled?: boolean;
   autoConfirmAppointments?: boolean;
   businessIdentificationNumber?: string | null;
@@ -221,6 +309,7 @@ export interface CreateClinicGroupData {
   practiceType?: PracticeType;
   languages?: Language[];
   subscriptionModel?: SubscriptionModel;
+  billing?: BillingInfo;
   calendarSyncEnabled?: boolean;
   autoConfirmAppointments?: boolean;
   businessIdentificationNumber?: string | null;

package/src/validations/clinic.schema.ts

@@ -4,6 +4,8 @@ import {
   ClinicTag,
   AdminTokenStatus,
   SubscriptionModel,
+  SubscriptionStatus,
+  BillingTransactionType,
   PracticeType,
   Language,
 } from "../types/clinic";
@@ -145,6 +147,70 @@ export const adminTokenSchema = z.object({
   expiresAt: z.instanceof(Date).or(z.instanceof(Timestamp)), // Timestamp
 });
 
+/**
+ * Validation schema for Stripe transaction data
+ */
+export const stripeTransactionDataSchema = z.object({
+  sessionId: z.string().optional(),
+  subscriptionId: z.string().optional(),
+  invoiceId: z.string().optional(),
+  priceId: z.string(),
+  customerId: z.string(),
+});
+
+/**
+ * Validation schema for plan details
+ */
+export const planDetailsSchema = z.object({
+  planName: z.string(),
+  planPeriod: z.string(),
+  planDisplayName: z.string(),
+});
+
+/**
+ * Validation schema for billing information
+ */
+export const billingInfoSchema = z.object({
+  stripeCustomerId: z.string(),
+  subscriptionStatus: z.nativeEnum(SubscriptionStatus),
+  planType: z.string(),
+  stripeSubscriptionId: z.string().nullable(),
+  stripePriceId: z.string().nullable(),
+  currentPeriodStart: z.instanceof(Date).or(z.instanceof(Timestamp)).nullable(),
+  currentPeriodEnd: z.instanceof(Date).or(z.instanceof(Timestamp)).nullable(),
+  updatedAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
+});
+
+/**
+ * Validation schema for billing transactions
+ */
+export const billingTransactionSchema = z.object({
+  id: z.string(),
+  clinicGroupId: z.string(),
+  type: z.nativeEnum(BillingTransactionType),
+  description: z.string(),
+  amount: z.number(),
+  currency: z.string(),
+  stripeData: stripeTransactionDataSchema,
+  planDetails: planDetailsSchema,
+  metadata: z.record(z.any()).optional(),
+  timestamp: z.instanceof(Date).or(z.instanceof(Timestamp)),
+  createdAt: z.instanceof(Date).or(z.instanceof(Timestamp)),
+});
+
+/**
+ * Validation schema for creating billing transactions
+ */
+export const createBillingTransactionSchema = z.object({
+  type: z.nativeEnum(BillingTransactionType),
+  description: z.string(),
+  amount: z.number(),
+  currency: z.string(),
+  stripeData: stripeTransactionDataSchema,
+  planDetails: planDetailsSchema,
+  metadata: z.record(z.any()).optional(),
+});
+
 /**
  * Validaciona šema za kreiranje admin tokena
  */
@@ -176,6 +242,7 @@ export const clinicGroupSchema = z.object({
   practiceType: z.nativeEnum(PracticeType).optional(),
   languages: z.array(z.nativeEnum(Language)).optional(),
   subscriptionModel: z.nativeEnum(SubscriptionModel),
+  billing: billingInfoSchema.optional(),
   calendarSyncEnabled: z.boolean().optional(),
   autoConfirmAppointments: z.boolean().optional(),
   businessIdentificationNumber: z.string().optional().nullable(),
@@ -254,6 +321,7 @@ export const createClinicGroupSchema = z.object({
     .nativeEnum(SubscriptionModel)
     .optional()
     .default(SubscriptionModel.NO_SUBSCRIPTION),
+  billing: billingInfoSchema.optional(),
   calendarSyncEnabled: z.boolean().optional(),
   autoConfirmAppointments: z.boolean().optional(),
   businessIdentificationNumber: z.string().optional().nullable(),