File size: 8,014 Bytes
028d116
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
d56049c
028d116
 
 
 
d56049c
028d116
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
d56049c
028d116
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5234643
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
from __future__ import annotations

import json
import os
from dataclasses import dataclass
from datetime import datetime, timezone
from typing import Any

from dotenv import load_dotenv


load_dotenv()


class FirebaseConfigError(RuntimeError):
    """Raised when Firebase configuration is missing or invalid."""


@dataclass
class CredentialsObject:
    """OAuth & API Keys for a tenant."""
    openai_api_key: str
    google_service_account_json: str


@dataclass
class RuleObject:
    """Processing rule for a tenant."""
    rule_id: str
    rule_name: str
    source_folder_id: str
    target_folder_id: str
    target_sheet_id: str
    sheet_tab_name: str
    parsing_prompt: str | None = None
    is_enabled: bool = True

    def to_dict(self) -> dict[str, Any]:
        return {
            "rule_id": self.rule_id,
            "rule_name": self.rule_name,
            "source_folder_id": self.source_folder_id,
            "target_folder_id": self.target_folder_id,
            "target_sheet_id": self.target_sheet_id,
            "sheet_tab_name": self.sheet_tab_name,
            "parsing_prompt": self.parsing_prompt,
            "is_enabled": self.is_enabled,
        }

    @staticmethod
    def from_dict(data: dict[str, Any]) -> RuleObject:
        return RuleObject(
            rule_id=data.get("rule_id", ""),
            rule_name=data.get("rule_name", ""),
            source_folder_id=data.get("source_folder_id", ""),
            target_folder_id=data.get("target_folder_id", ""),
            target_sheet_id=data.get("target_sheet_id", ""),
            sheet_tab_name=data.get("sheet_tab_name", ""),
            parsing_prompt=data.get("parsing_prompt"),
            is_enabled=data.get("is_enabled", True),
        )


@dataclass
class TenantConfig:
    """Complete tenant configuration (rules stored inside tenant document)."""
    tenant_id: str
    name: str
    active: bool
    credentials: CredentialsObject
    rules: list[RuleObject] | None = None
    created_at: str | None = None

    def to_dict(self) -> dict[str, Any]:
        return {
            "tenant_id": self.tenant_id,
            "name": self.name,
            "active": self.active,
            "credentials": {
                "openai_api_key": self.credentials.openai_api_key,
                "google_service_account_json": self.credentials.google_service_account_json,
            },
            "created_at": self.created_at,
        }

    @staticmethod
    def from_dict(data: dict[str, Any], tenant_id: str) -> TenantConfig:
        creds_data = data.get("credentials", {})
        credentials = CredentialsObject(
            openai_api_key=creds_data.get("openai_api_key", ""),
            google_service_account_json=creds_data.get("google_service_account_json", ""),
        )
        return TenantConfig(
            tenant_id=tenant_id,
            name=data.get("name", ""),
            active=data.get("active", True),
            credentials=credentials,
            rules=None,
            created_at=data.get("created_at"),
        )


class FirebaseTenantConfigManager:
    """Manages tenant configurations in Firebase Firestore.
    
    This is the TENANT CONFIG DB - separate from document processing.
    Other environments import this and use get_tenant() to fetch configs.
    """

    def __init__(self, collection_name: str | None = None):
        self.collection_name = (collection_name or os.getenv("FIREBASE_TENANTS_COLLECTION") or "tenants").strip()
        self._db = None

    def _build_credentials(self):
        from firebase_admin import credentials

        service_account_json = (os.getenv("FIREBASE_SERVICE_ACCOUNT_JSON") or "").strip()
        service_account_file = (os.getenv("FIREBASE_SERVICE_ACCOUNT_FILE") or "").strip()

        if not service_account_json:
            service_account_json = (os.getenv("GOOGLE_SERVICE_ACCOUNT_JSON") or "").strip()
        if not service_account_file:
            service_account_file = (os.getenv("GOOGLE_SERVICE_ACCOUNT_FILE") or "").strip()

        if service_account_json:
            try:
                info = json.loads(service_account_json)
            except json.JSONDecodeError as exc:
                raise FirebaseConfigError("FIREBASE_SERVICE_ACCOUNT_JSON is not valid JSON.") from exc
            return credentials.Certificate(info)

        if service_account_file:
            return credentials.Certificate(service_account_file)

        raise FirebaseConfigError(
            "Missing Firebase credentials. Set FIREBASE_SERVICE_ACCOUNT_JSON or FIREBASE_SERVICE_ACCOUNT_FILE."
        )

    def _get_db(self):
        if self._db is not None:
            return self._db

        import firebase_admin
        from firebase_admin import firestore

        if not firebase_admin._apps:
            cred = self._build_credentials()
            firebase_admin.initialize_app(cred)

        self._db = firestore.client()
        return self._db

    def get_tenant(self, tenant_id: str) -> TenantConfig | None:
        """Retrieve a tenant configuration by ID."""
        doc = self._get_db().collection(self.collection_name).document(tenant_id).get()
        if not doc.exists:
            return None
        data = doc.to_dict() or {}
        return TenantConfig.from_dict(data, tenant_id)

    def save_tenant(self, tenant: TenantConfig) -> None:
        """Save a tenant configuration."""
        payload = tenant.to_dict()
        if not payload.get("created_at"):
            payload["created_at"] = datetime.now(timezone.utc).isoformat()
        payload["updated_at"] = datetime.now(timezone.utc).isoformat()
        self._get_db().collection(self.collection_name).document(tenant.tenant_id).set(payload)

    def list_active_tenants(self) -> list[TenantConfig]:
        """Retrieve all active tenants."""
        docs = (
            self._get_db()
            .collection(self.collection_name)
            .where("active", "==", True)
            .stream()
        )
        tenants = []
        for doc in docs:
            try:
                tenant = TenantConfig.from_dict(doc.to_dict() or {}, doc.id)
                tenants.append(tenant)
            except Exception:
                continue
        return tenants

    def get_all_rules(self, tenant_id: str) -> list[RuleObject]:
        """Get all processing rules for a tenant from the rules subcollection."""
        tenant_doc = self._get_db().collection(self.collection_name).document(tenant_id)
        rules_subcoll = tenant_doc.collection("rules")
        rules = []
        for doc in rules_subcoll.stream():
            rule_data = doc.to_dict() or {}
            rules.append(RuleObject.from_dict(rule_data))
        return rules

    def get_enabled_rules(self, tenant_id: str) -> list[RuleObject]:
        """Get all enabled processing rules for a tenant."""
        all_rules = self.get_all_rules(tenant_id)
        return [rule for rule in all_rules if rule.is_enabled]

    def add_rule(self, tenant_id: str, rule: RuleObject) -> None:
        """Add a rule to a tenant's rules subcollection."""
        tenant_doc = self._get_db().collection(self.collection_name).document(tenant_id)
        rules_subcoll = tenant_doc.collection("rules")
        rules_subcoll.document(rule.rule_id).set(rule.to_dict())

    def remove_rule(self, tenant_id: str, rule_id: str) -> None:
        """Remove a rule from a tenant's rules subcollection."""
        tenant_doc = self._get_db().collection(self.collection_name).document(tenant_id)
        rules_subcoll = tenant_doc.collection("rules")
        rules_subcoll.document(rule_id).delete()


# Module-level convenience functions for backward compatibility
_manager = FirebaseTenantConfigManager()


def load_all_tenants() -> list[TenantConfig]:
    """Load all active tenants from Firebase."""
    return _manager.list_active_tenants()


def load_tenant_rules(tenant_id: str) -> list[RuleObject]:
    """Load all rules for a specific tenant."""
    return _manager.get_all_rules(tenant_id)