fix telegram

2026-02-23 15:12:33 +00:00
parent 6c78fec8a7
commit 8bc567a9c5
426 changed files with 112478 additions and 1 deletions
--- a/deploy-package-20260223-151231/shared/frontend/stores/accountingPeriod.js
+++ b/deploy-package-20260223-151231/shared/frontend/stores/accountingPeriod.js
@@ -0,0 +1,158 @@
+/**
+ * Shared Accounting Period Store Factory
+ *
+ * Creates a Pinia store for accounting period selection that can be used by any ROA2WEB application.
+ * Each app passes its own apiService and store references.
+ *
+ * Usage:
+ *   import { createAccountingPeriodStore } from '@shared/frontend/stores/accountingPeriod';
+ *   import { apiService } from '../services/api';
+ *   import { useAuthStore } from './auth';
+ *   import { useCompanyStore } from './companies';
+ *   export const useAccountingPeriodStore = createAccountingPeriodStore(apiService, useAuthStore, useCompanyStore);
+ */
+
+import { defineStore } from "pinia";
+import { ref, computed } from "vue";
+
+/**
+ * Factory function to create an accounting period store
+ * @param {Object} apiService - Axios instance configured for the app's API
+ * @param {Function} useAuthStore - Reference to the auth store function
+ * @param {Function} useCompanyStore - Reference to the company store function
+ * @returns {Function} Pinia store definition
+ */
+export function createAccountingPeriodStore(apiService, useAuthStore, useCompanyStore) {
+  return defineStore("accountingPeriod", () => {
+    // State
+    const periods = ref([]);
+    const selectedPeriod = ref(null);
+    const isLoading = ref(false);
+    const error = ref(null);
+
+    // Getters
+    const hasPeriods = computed(() => periods.value.length > 0);
+    const currentPeriod = computed(() => selectedPeriod.value);
+
+    // Computed date range for current period (first/last day of month)
+    const dateRange = computed(() => {
+      if (!selectedPeriod.value) return { dateFrom: null, dateTo: null };
+
+      const { an, luna } = selectedPeriod.value;
+      const firstDay = new Date(an, luna - 1, 1);
+      const lastDay = new Date(an, luna, 0);
+
+      return {
+        dateFrom: firstDay,
+        dateTo: lastDay,
+      };
+    });
+
+    // localStorage helpers
+    const getStorageKey = () => {
+      const authStore = useAuthStore();
+      const companyStore = useCompanyStore();
+      const username = authStore.user?.username;
+      const companyId = companyStore.selectedCompany?.id_firma;
+      if (!username || !companyId) return null;
+      return `selected_period_${username}_${companyId}`;
+    };
+
+    const initializeSelectedPeriod = () => {
+      const key = getStorageKey();
+      if (!key) return null;
+
+      const saved = localStorage.getItem(key);
+      if (saved) {
+        try {
+          return JSON.parse(saved);
+        } catch (e) {
+          localStorage.removeItem(key);
+        }
+      }
+      return null;
+    };
+
+    const persistSelectedPeriod = (period) => {
+      const key = getStorageKey();
+      if (key && period) {
+        localStorage.setItem(key, JSON.stringify(period));
+      }
+    };
+
+    // Actions
+    const loadPeriods = async (companyId) => {
+      if (!companyId) return { success: false };
+
+      isLoading.value = true;
+      error.value = null;
+
+      try {
+        const response = await apiService.get("/calendar/periods", {
+          params: { company: companyId },
+        });
+
+        periods.value = response.data.periods || [];
+
+        // Try to restore saved period or use most recent
+        const saved = initializeSelectedPeriod();
+        if (saved) {
+          const exists = periods.value.find(
+            (p) => p.an === saved.an && p.luna === saved.luna
+          );
+          if (exists) {
+            selectedPeriod.value = exists;
+          } else if (response.data.current_period) {
+            setSelectedPeriod(response.data.current_period);
+          }
+        } else if (response.data.current_period) {
+          setSelectedPeriod(response.data.current_period);
+        }
+
+        return { success: true };
+      } catch (err) {
+        error.value = err.response?.data?.detail || "Failed to load periods";
+        return { success: false, error: error.value };
+      } finally {
+        isLoading.value = false;
+      }
+    };
+
+    const setSelectedPeriod = (period) => {
+      selectedPeriod.value = period;
+      persistSelectedPeriod(period);
+    };
+
+    const resetToLatest = () => {
+      if (periods.value.length > 0) {
+        setSelectedPeriod(periods.value[0]);
+      }
+    };
+
+    const reset = () => {
+      periods.value = [];
+      selectedPeriod.value = null;
+      isLoading.value = false;
+      error.value = null;
+    };
+
+    return {
+      // State
+      periods,
+      selectedPeriod,
+      isLoading,
+      error,
+
+      // Getters
+      hasPeriods,
+      currentPeriod,
+      dateRange,
+
+      // Actions
+      loadPeriods,
+      setSelectedPeriod,
+      resetToLatest,
+      reset,
+    };
+  });
+}
--- a/deploy-package-20260223-151231/shared/frontend/stores/auth.js
+++ b/deploy-package-20260223-151231/shared/frontend/stores/auth.js
@@ -0,0 +1,133 @@
+/**
+ * Shared Auth Store Factory
+ *
+ * Creates a Pinia auth store that can be used by any ROA2WEB application.
+ * Each app passes its own apiService instance configured with the correct baseURL.
+ *
+ * Usage:
+ *   import { createAuthStore } from '@shared/frontend/stores/auth';
+ *   import { apiService } from '../services/api';
+ *   export const useAuthStore = createAuthStore(apiService);
+ */
+
+import { defineStore } from "pinia";
+import { ref, computed } from "vue";
+
+/**
+ * Factory function to create an auth store with the provided API service
+ * @param {Object} apiService - Axios instance configured for the app's API
+ * @returns {Function} Pinia store definition
+ */
+export function createAuthStore(apiService) {
+  return defineStore("auth", () => {
+    // State
+    const accessToken = ref(localStorage.getItem("access_token"));
+    const refreshToken = ref(localStorage.getItem("refresh_token"));
+    const user = ref(JSON.parse(localStorage.getItem("user") || "null"));
+    const isLoading = ref(false);
+    const error = ref(null);
+
+    // Getters
+    const isAuthenticated = computed(() => !!accessToken.value);
+    const currentUser = computed(() => user.value);
+
+    // Actions
+    const login = async (credentials) => {
+      isLoading.value = true;
+      error.value = null;
+
+      try {
+        const response = await apiService.post("/auth/login", {
+          username: credentials.username,
+          password: credentials.password,
+        });
+        const { access_token, refresh_token, user: userData } = response.data;
+
+        accessToken.value = access_token;
+        refreshToken.value = refresh_token;
+        user.value = userData;
+
+        localStorage.setItem("access_token", access_token);
+        localStorage.setItem("refresh_token", refresh_token);
+        localStorage.setItem("user", JSON.stringify(userData));
+
+        apiService.defaults.headers.common["Authorization"] = `Bearer ${access_token}`;
+
+        return { success: true };
+      } catch (err) {
+        error.value = err.response?.data?.detail || "Login failed";
+        return { success: false, error: error.value };
+      } finally {
+        isLoading.value = false;
+      }
+    };
+
+    const logout = () => {
+      accessToken.value = null;
+      refreshToken.value = null;
+      user.value = null;
+      error.value = null;
+
+      localStorage.removeItem("access_token");
+      localStorage.removeItem("refresh_token");
+      localStorage.removeItem("user");
+
+      delete apiService.defaults.headers.common["Authorization"];
+    };
+
+    const refreshAccessToken = async () => {
+      if (!refreshToken.value) {
+        logout();
+        return false;
+      }
+
+      try {
+        const response = await apiService.post("/auth/refresh", {
+          refresh_token: refreshToken.value,
+        });
+
+        const { access_token } = response.data;
+        accessToken.value = access_token;
+        localStorage.setItem("access_token", access_token);
+        apiService.defaults.headers.common["Authorization"] = `Bearer ${access_token}`;
+
+        return true;
+      } catch (err) {
+        console.error("Token refresh failed:", err);
+        logout();
+        return false;
+      }
+    };
+
+    const initializeAuth = () => {
+      if (accessToken.value) {
+        apiService.defaults.headers.common["Authorization"] = `Bearer ${accessToken.value}`;
+      }
+    };
+
+    const clearError = () => {
+      error.value = null;
+    };
+
+    // Initialize on store creation
+    initializeAuth();
+
+    return {
+      // State
+      accessToken,
+      refreshToken,
+      user,
+      isLoading,
+      error,
+      // Getters
+      isAuthenticated,
+      currentUser,
+      // Actions
+      login,
+      logout,
+      refreshAccessToken,
+      initializeAuth,
+      clearError,
+    };
+  });
+}
--- a/deploy-package-20260223-151231/shared/frontend/stores/companies.js
+++ b/deploy-package-20260223-151231/shared/frontend/stores/companies.js
@@ -0,0 +1,196 @@
+/**
+ * Shared Companies Store Factory
+ *
+ * Creates a Pinia store for company selection that can be used by any ROA2WEB application.
+ * Each app passes its own apiService and auth store instances.
+ *
+ * Usage:
+ *   import { createCompaniesStore } from '@shared/frontend/stores/companies';
+ *   import { apiService } from '../services/api';
+ *   import { useAuthStore } from './auth';
+ *   export const useCompanyStore = createCompaniesStore(apiService, useAuthStore);
+ */
+
+import { defineStore } from "pinia";
+import { ref, computed, watch } from "vue";
+
+/**
+ * Factory function to create a companies store
+ * @param {Object} apiService - Axios instance configured for the app's API
+ * @param {Function} useAuthStore - Reference to the auth store function
+ * @returns {Function} Pinia store definition
+ */
+export function createCompaniesStore(apiService, useAuthStore) {
+  return defineStore("companies", () => {
+    // State
+    const companies = ref([]);
+    const selectedCompany = ref(null);
+    const isLoading = ref(false);
+    const error = ref(null);
+
+    // Initialize from localStorage - per user
+    const initializeSelectedCompany = () => {
+      const authStore = useAuthStore();
+      const username = authStore.user?.username;
+
+      if (!username) {
+        console.log("[Companies] No username available for initialization");
+        return null;
+      }
+
+      const key = `selected_company_${username}`;
+      const saved = localStorage.getItem(key);
+      if (saved) {
+        try {
+          const company = JSON.parse(saved);
+          console.log(`[Companies] Loaded saved company for ${username}:`, company.name);
+          return company;
+        } catch (e) {
+          console.error("Failed to parse saved company", e);
+          localStorage.removeItem(key);
+        }
+      }
+      return null;
+    };
+
+    // Watch for auth user changes to restore selected company
+    const authStore = useAuthStore();
+    watch(
+      () => authStore.user,
+      (newUser) => {
+        if (newUser && newUser.username && !selectedCompany.value) {
+          const restoredCompany = initializeSelectedCompany();
+          if (restoredCompany) {
+            selectedCompany.value = restoredCompany;
+            console.log("[Companies] Restored selected company:", restoredCompany.name);
+          }
+        }
+      },
+      { immediate: true }
+    );
+
+    // Getters
+    const companyList = computed(() => companies.value);
+    const hasCompanies = computed(() => companies.value.length > 0);
+    const selectedCompanyId = computed(() => selectedCompany.value?.id_firma || null);
+
+    const companyListFormatted = computed(() => {
+      return companies.value.map((company) => ({
+        ...company,
+        displayName: company.fiscal_code
+          ? `${company.name} (${company.fiscal_code})`
+          : company.name,
+      }));
+    });
+
+    // Actions
+    const loadCompanies = async () => {
+      isLoading.value = true;
+      error.value = null;
+
+      try {
+        console.log("[Companies] Loading companies...");
+        const response = await apiService.get("/companies");
+        companies.value = response.data.companies || [];
+        console.log("[Companies] Loaded", companies.value.length, "companies");
+
+        // Validate saved company is still accessible
+        if (selectedCompany.value) {
+          const exists = companies.value.find(
+            (c) => c.id_firma === selectedCompany.value.id_firma
+          );
+          if (!exists) {
+            console.warn("[Companies] Saved company not accessible, clearing");
+            clearSelectedCompany();
+          }
+        }
+
+        return { success: true };
+      } catch (err) {
+        error.value = err.response?.data?.detail || "Failed to load companies";
+        console.error("Failed to load companies:", err);
+        return { success: false, error: error.value };
+      } finally {
+        isLoading.value = false;
+      }
+    };
+
+    const setSelectedCompany = (company) => {
+      selectedCompany.value = company;
+
+      const authStore = useAuthStore();
+      const username = authStore.user?.username;
+
+      if (!username) {
+        console.warn("[Companies] Cannot save - no username");
+        return;
+      }
+
+      const key = `selected_company_${username}`;
+      if (company) {
+        localStorage.setItem(key, JSON.stringify(company));
+        console.log(`[Companies] Saved company for ${username}:`, company.name);
+      } else {
+        localStorage.removeItem(key);
+      }
+    };
+
+    const clearSelectedCompany = () => {
+      selectedCompany.value = null;
+
+      const authStore = useAuthStore();
+      const username = authStore.user?.username;
+
+      if (username) {
+        const key = `selected_company_${username}`;
+        localStorage.removeItem(key);
+      }
+    };
+
+    const getCompanyById = (id_firma) => {
+      return companies.value.find(
+        (company) => company.id_firma === parseInt(id_firma)
+      );
+    };
+
+    const clearError = () => {
+      error.value = null;
+    };
+
+    const reset = () => {
+      companies.value = [];
+      selectedCompany.value = null;
+      isLoading.value = false;
+      error.value = null;
+
+      const authStore = useAuthStore();
+      const username = authStore.user?.username;
+      if (username) {
+        const key = `selected_company_${username}`;
+        localStorage.removeItem(key);
+      }
+    };
+
+    return {
+      // State
+      companies,
+      selectedCompany,
+      isLoading,
+      error,
+
+      // Getters
+      companyList,
+      companyListFormatted,
+      hasCompanies,
+      selectedCompanyId,
+
+      // Actions
+      loadCompanies,
+      setSelectedCompany,
+      clearSelectedCompany,
+      getCompanyById,
+      clearError,
+      reset,
+    };
+  });
+}