Add supplier and imporve inventory frontend

frontend/src/utils/enumHelpers.ts

@@ -0,0 +1,166 @@
+// frontend/src/utils/enumHelpers.ts
+/**
+ * Utilities for working with enums and translations
+ */
+
+import { useTranslation } from 'react-i18next';
+import type { SelectOption } from '../components/ui/Select';
+import {
+  SupplierType,
+  SupplierStatus,
+  PaymentTerms,
+  PurchaseOrderStatus,
+  DeliveryStatus,
+  QualityRating,
+  DeliveryRating,
+  InvoiceStatus,
+  type EnumOption
+} from '../api/types/suppliers';
+
+/**
+ * Generic function to convert enum to select options with i18n translations
+ */
+export function enumToSelectOptions<T extends Record<string, string | number>>(
+  enumObject: T,
+  translationKey: string,
+  t: (key: string) => string,
+  options?: {
+    includeDescription?: boolean;
+    descriptionKey?: string;
+    sortAlphabetically?: boolean;
+  }
+): SelectOption[] {
+  const selectOptions = Object.entries(enumObject).map(([key, value]) => ({
+    value,
+    label: t(`${translationKey}.${value}`),
+    ...(options?.includeDescription && options?.descriptionKey && {
+      description: t(`${options.descriptionKey}.${value}`)
+    })
+  }));
+
+  if (options?.sortAlphabetically) {
+    selectOptions.sort((a, b) => a.label.localeCompare(b.label));
+  }
+
+  return selectOptions;
+}
+
+/**
+ * Hook for supplier enum utilities
+ */
+export function useSupplierEnums() {
+  const { t } = useTranslation('suppliers');
+
+  return {
+    // Supplier Type
+    getSupplierTypeOptions: (): SelectOption[] =>
+      enumToSelectOptions(SupplierType, 'types', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getSupplierTypeLabel: (type: SupplierType): string => {
+      if (!type) return 'Tipo no definido';
+      return t(`types.${type}`);
+    },
+
+    // Supplier Status
+    getSupplierStatusOptions: (): SelectOption[] =>
+      enumToSelectOptions(SupplierStatus, 'status', t),
+
+    getSupplierStatusLabel: (status: SupplierStatus): string => {
+      if (!status) return 'Estado no definido';
+      return t(`status.${status}`);
+    },
+
+    // Payment Terms
+    getPaymentTermsOptions: (): SelectOption[] =>
+      enumToSelectOptions(PaymentTerms, 'payment_terms', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getPaymentTermsLabel: (terms: PaymentTerms): string => {
+      if (!terms) return 'Sin términos definidos';
+      return t(`payment_terms.${terms}`);
+    },
+
+    // Purchase Order Status
+    getPurchaseOrderStatusOptions: (): SelectOption[] =>
+      enumToSelectOptions(PurchaseOrderStatus, 'purchase_order_status', t),
+
+    getPurchaseOrderStatusLabel: (status: PurchaseOrderStatus): string => {
+      if (!status) return 'Estado no definido';
+      return t(`purchase_order_status.${status}`);
+    },
+
+    // Delivery Status
+    getDeliveryStatusOptions: (): SelectOption[] =>
+      enumToSelectOptions(DeliveryStatus, 'delivery_status', t),
+
+    getDeliveryStatusLabel: (status: DeliveryStatus): string => {
+      if (!status) return 'Estado no definido';
+      return t(`delivery_status.${status}`);
+    },
+
+    // Quality Rating
+    getQualityRatingOptions: (): SelectOption[] =>
+      enumToSelectOptions(QualityRating, 'quality_rating', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getQualityRatingLabel: (rating: QualityRating): string => {
+      if (rating === undefined || rating === null) return 'Sin calificación';
+      return t(`quality_rating.${rating}`);
+    },
+
+    // Delivery Rating
+    getDeliveryRatingOptions: (): SelectOption[] =>
+      enumToSelectOptions(DeliveryRating, 'delivery_rating', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getDeliveryRatingLabel: (rating: DeliveryRating): string => {
+      if (rating === undefined || rating === null) return 'Sin calificación';
+      return t(`delivery_rating.${rating}`);
+    },
+
+    // Invoice Status
+    getInvoiceStatusOptions: (): SelectOption[] =>
+      enumToSelectOptions(InvoiceStatus, 'invoice_status', t),
+
+    getInvoiceStatusLabel: (status: InvoiceStatus): string => {
+      if (!status) return 'Estado no definido';
+      return t(`invoice_status.${status}`);
+    },
+
+    // Field Labels
+    getFieldLabel: (field: string): string =>
+      t(`labels.${field}`),
+
+    getFieldDescription: (field: string): string =>
+      t(`descriptions.${field}`)
+  };
+}
+
+/**
+ * Utility to get enum value from select option value
+ */
+export function getEnumFromValue<T>(
+  enumObject: Record<string, T>,
+  value: string | number
+): T | undefined {
+  return Object.values(enumObject).find(enumValue => enumValue === value);
+}
+
+/**
+ * Utility to validate enum value
+ */
+export function isValidEnumValue<T>(
+  enumObject: Record<string, T>,
+  value: unknown
+): value is T {
+  return Object.values(enumObject).includes(value as T);
+}

frontend/src/utils/foodSafetyEnumHelpers.ts

@@ -0,0 +1,109 @@
+// frontend/src/utils/foodSafetyEnumHelpers.ts
+/**
+ * Utilities for working with food safety enums and translations
+ */
+
+import { useTranslation } from 'react-i18next';
+import type { SelectOption } from '../components/ui/Select';
+import {
+  FoodSafetyStandard,
+  ComplianceStatus,
+  FoodSafetyAlertType,
+  type EnumOption
+} from '../api/types/foodSafety';
+
+/**
+ * Generic function to convert enum to select options with i18n translations
+ */
+export function enumToSelectOptions<T extends Record<string, string | number>>(
+  enumObject: T,
+  translationKey: string,
+  t: (key: string) => string,
+  options?: {
+    includeDescription?: boolean;
+    descriptionKey?: string;
+    sortAlphabetically?: boolean;
+  }
+): SelectOption[] {
+  const selectOptions = Object.entries(enumObject).map(([, value]) => ({
+    value,
+    label: t(`${translationKey}.${value}`),
+    ...(options?.includeDescription && options?.descriptionKey && {
+      description: t(`${options.descriptionKey}.${value}`)
+    })
+  }));
+
+  if (options?.sortAlphabetically) {
+    selectOptions.sort((a, b) => a.label.localeCompare(b.label));
+  }
+
+  return selectOptions;
+}
+
+/**
+ * Hook for food safety enum utilities
+ */
+export function useFoodSafetyEnums() {
+  const { t } = useTranslation('foodSafety');
+
+  return {
+    // Food Safety Standard
+    getFoodSafetyStandardOptions: (): SelectOption[] =>
+      enumToSelectOptions(FoodSafetyStandard, 'enums.food_safety_standard', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions',
+        sortAlphabetically: true
+      }),
+
+    getFoodSafetyStandardLabel: (standard: FoodSafetyStandard): string =>
+      t(`enums.food_safety_standard.${standard}`),
+
+    // Compliance Status
+    getComplianceStatusOptions: (): SelectOption[] =>
+      enumToSelectOptions(ComplianceStatus, 'enums.compliance_status', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getComplianceStatusLabel: (status: ComplianceStatus): string =>
+      t(`enums.compliance_status.${status}`),
+
+    // Food Safety Alert Type
+    getFoodSafetyAlertTypeOptions: (): SelectOption[] =>
+      enumToSelectOptions(FoodSafetyAlertType, 'enums.food_safety_alert_type', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions',
+        sortAlphabetically: true
+      }),
+
+    getFoodSafetyAlertTypeLabel: (type: FoodSafetyAlertType): string =>
+      t(`enums.food_safety_alert_type.${type}`),
+
+    // Field Labels
+    getFieldLabel: (field: string): string =>
+      t(`labels.${field}`),
+
+    getFieldDescription: (field: string): string =>
+      t(`descriptions.${field}`)
+  };
+}
+
+/**
+ * Utility to get enum value from select option value
+ */
+export function getEnumFromValue<T>(
+  enumObject: Record<string, T>,
+  value: string | number
+): T | undefined {
+  return Object.values(enumObject).find(enumValue => enumValue === value);
+}
+
+/**
+ * Utility to validate enum value
+ */
+export function isValidEnumValue<T>(
+  enumObject: Record<string, T>,
+  value: unknown
+): value is T {
+  return Object.values(enumObject).includes(value as T);
+}

frontend/src/utils/inventoryEnumHelpers.ts

@@ -0,0 +1,140 @@
+// frontend/src/utils/inventoryEnumHelpers.ts
+/**
+ * Utilities for working with inventory enums and translations
+ */
+
+import { useTranslation } from 'react-i18next';
+import type { SelectOption } from '../components/ui/Select';
+import {
+  ProductType,
+  ProductionStage,
+  UnitOfMeasure,
+  IngredientCategory,
+  ProductCategory,
+  StockMovementType,
+  type EnumOption
+} from '../api/types/inventory';
+
+/**
+ * Generic function to convert enum to select options with i18n translations
+ */
+export function enumToSelectOptions<T extends Record<string, string | number>>(
+  enumObject: T,
+  translationKey: string,
+  t: (key: string) => string,
+  options?: {
+    includeDescription?: boolean;
+    descriptionKey?: string;
+    sortAlphabetically?: boolean;
+  }
+): SelectOption[] {
+  const selectOptions = Object.entries(enumObject).map(([, value]) => ({
+    value,
+    label: t(`${translationKey}.${value}`),
+    ...(options?.includeDescription && options?.descriptionKey && {
+      description: t(`${options.descriptionKey}.${value}`)
+    })
+  }));
+
+  if (options?.sortAlphabetically) {
+    selectOptions.sort((a, b) => a.label.localeCompare(b.label));
+  }
+
+  return selectOptions;
+}
+
+/**
+ * Hook for inventory enum utilities
+ */
+export function useInventoryEnums() {
+  const { t } = useTranslation('inventory');
+
+  return {
+    // Product Type
+    getProductTypeOptions: (): SelectOption[] =>
+      enumToSelectOptions(ProductType, 'enums.product_type', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getProductTypeLabel: (type: ProductType): string =>
+      t(`enums.product_type.${type}`),
+
+    // Production Stage
+    getProductionStageOptions: (): SelectOption[] =>
+      enumToSelectOptions(ProductionStage, 'enums.production_stage', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getProductionStageLabel: (stage: ProductionStage): string =>
+      t(`enums.production_stage.${stage}`),
+
+    // Unit of Measure
+    getUnitOfMeasureOptions: (): SelectOption[] =>
+      enumToSelectOptions(UnitOfMeasure, 'enums.unit_of_measure', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getUnitOfMeasureLabel: (unit: UnitOfMeasure): string =>
+      t(`enums.unit_of_measure.${unit}`),
+
+    // Ingredient Category
+    getIngredientCategoryOptions: (): SelectOption[] =>
+      enumToSelectOptions(IngredientCategory, 'enums.ingredient_category', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions',
+        sortAlphabetically: true
+      }),
+
+    getIngredientCategoryLabel: (category: IngredientCategory): string =>
+      t(`enums.ingredient_category.${category}`),
+
+    // Product Category
+    getProductCategoryOptions: (): SelectOption[] =>
+      enumToSelectOptions(ProductCategory, 'enums.product_category', t, {
+        sortAlphabetically: true
+      }),
+
+    getProductCategoryLabel: (category: ProductCategory): string =>
+      t(`enums.product_category.${category}`),
+
+    // Stock Movement Type
+    getStockMovementTypeOptions: (): SelectOption[] =>
+      enumToSelectOptions(StockMovementType, 'enums.stock_movement_type', t, {
+        includeDescription: true,
+        descriptionKey: 'descriptions'
+      }),
+
+    getStockMovementTypeLabel: (type: StockMovementType): string =>
+      t(`enums.stock_movement_type.${type}`),
+
+    // Field Labels
+    getFieldLabel: (field: string): string =>
+      t(`labels.${field}`),
+
+    getFieldDescription: (field: string): string =>
+      t(`descriptions.${field}`)
+  };
+}
+
+/**
+ * Utility to get enum value from select option value
+ */
+export function getEnumFromValue<T>(
+  enumObject: Record<string, T>,
+  value: string | number
+): T | undefined {
+  return Object.values(enumObject).find(enumValue => enumValue === value);
+}
+
+/**
+ * Utility to validate enum value
+ */
+export function isValidEnumValue<T>(
+  enumObject: Record<string, T>,
+  value: unknown
+): value is T {
+  return Object.values(enumObject).includes(value as T);
+}