constec 0.7.1__py3-none-any.whl

constec/db/models/erp.py

@@ -0,0 +1,101 @@
+from django.db import models
+from .base import UUIDModel
+from .company import Company
+
+
+class System(UUIDModel):
+    """ERP system definition - independent of any company.
+
+    An ERP system can be shared across multiple companies via CompanySystem.
+    """
+    name = models.CharField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+    api_endpoint = models.URLField(max_length=200, blank=True)
+    metadata = models.JSONField(default=dict, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'erp"."systems'
+
+    def __str__(self):
+        return f"{self.name}"
+
+
+class CompanySystem(UUIDModel):
+    """Junction table linking companies to ERP systems.
+
+    Allows many-to-many relationship:
+    - A company can use multiple ERP systems
+    - An ERP system can be used by multiple companies
+    """
+    company = models.ForeignKey(
+        Company,
+        on_delete=models.CASCADE,
+        related_name="erp_systems",
+    )
+    system = models.ForeignKey(
+        System,
+        on_delete=models.CASCADE,
+        related_name="company_assignments",
+    )
+    is_primary = models.BooleanField(
+        default=False,
+        help_text="Whether this is the primary ERP system for the company"
+    )
+    metadata = models.JSONField(default=dict, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'erp"."company_systems'
+        unique_together = [['company', 'system']]
+        indexes = [
+            models.Index(fields=['company', 'is_primary']),
+            models.Index(fields=['system', 'is_active']),
+        ]
+
+    def __str__(self):
+        primary = " (Primary)" if self.is_primary else ""
+        return f"{self.company.name} → {self.system.name}{primary}"
+
+
+class Connection(UUIDModel):
+    """Database connection credentials for an ERP system."""
+
+    DB_TYPE_CHOICES = [
+        ('mssql', 'SQL Server'),
+        ('postgresql', 'PostgreSQL'),
+        ('mysql', 'MySQL'),
+    ]
+
+    company = models.ForeignKey(
+        Company,
+        on_delete=models.CASCADE,
+        related_name="erp_connections",
+    )
+    system = models.ForeignKey(
+        System,
+        on_delete=models.CASCADE,
+        related_name="connections",
+    )
+    name = models.CharField(
+        max_length=100,
+        blank=True,
+        default='',
+        help_text="Descriptive name for this connection"
+    )
+    slug = models.CharField(max_length=50)
+    db_type = models.CharField(max_length=20, choices=DB_TYPE_CHOICES, default='mssql')
+    host = models.CharField(max_length=255)
+    port = models.IntegerField()
+    database = models.CharField(max_length=100)
+    username = models.CharField(max_length=100)
+    encrypted_password = models.TextField()
+    last_tested_at = models.DateTimeField(null=True, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'erp"."connections'
+        unique_together = [['system', 'slug']]
+
+    def __str__(self):
+        return f"{self.name}" if self.name else f"{self.system.name} ({self.slug})"

constec/db/models/erp_entity.py

@@ -0,0 +1,122 @@
+from django.core.exceptions import ValidationError
+from django.db import models
+from .base import UUIDModel
+from .company import Company
+from .erp import System
+from .person import Person
+
+
+class Role(UUIDModel):
+    """Roles within the ERP (customer, supplier, seller)."""
+    system = models.ForeignKey(
+        System,
+        on_delete=models.CASCADE,
+        related_name="roles",
+    )
+    name = models.CharField(max_length=100)
+    description = models.TextField(blank=True, null=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'erp"."roles'
+        unique_together = [['system', 'name']]
+
+    def __str__(self):
+        return f"{self.name}"
+
+
+class Entity(UUIDModel):
+    """Link between ERP external entities and Core persons.
+
+    An Entity can exist without a Person (when someone has ERP access
+    but no Core account yet). When they authenticate via CUIT, we can
+    optionally link them to a Person later.
+    """
+    company = models.ForeignKey(
+        Company,
+        on_delete=models.CASCADE,
+        related_name="erp_entities",
+    )
+    person = models.ForeignKey(
+        Person,
+        on_delete=models.CASCADE,
+        related_name="erp_entities",
+        null=True,
+        blank=True,
+        help_text="Optional link to Core person"
+    )
+    system = models.ForeignKey(
+        System,
+        on_delete=models.CASCADE,
+        related_name="entities",
+    )
+    role = models.ForeignKey(
+        Role,
+        on_delete=models.PROTECT,
+        related_name="entities",
+    )
+    external_id = models.CharField(
+        max_length=255,
+        help_text="Entity ID in external ERP system (e.g., cli_Cod, pro_Cod)"
+    )
+    cuit = models.CharField(
+        max_length=13,
+        blank=True,
+        default='',
+        help_text="CUIT without dashes (for authentication lookup)"
+    )
+    metadata = models.JSONField(default=dict, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'erp"."entities'
+        verbose_name_plural = 'Entities'
+        unique_together = [['company', 'role', 'external_id']]
+        indexes = [
+            models.Index(fields=['cuit']),
+            models.Index(fields=['company', 'cuit']),
+        ]
+
+    def clean(self):
+        from .erp import CompanySystem
+        if not CompanySystem.objects.filter(company=self.company, system=self.system).exists():
+            raise ValidationError(
+                f"Company {self.company} is not associated with System {self.system}"
+            )
+
+    def __str__(self):
+        person_info = f"({self.person.full_name})" if self.person else "(no person linked)"
+        return f"[{self.system.name}] {self.role.name} {self.external_id} {person_info}"
+
+
+class EntityAuth(UUIDModel):
+    """Authentication credentials for ERP entities.
+
+    Stores hashed passwords for entities that can authenticate via Constancia AI.
+    Linked to Entity (which may or may not have a Person linked).
+    """
+    entity = models.OneToOneField(
+        Entity,
+        on_delete=models.CASCADE,
+        related_name="auth",
+        help_text="The ERP entity these credentials belong to"
+    )
+    password_hash = models.CharField(
+        max_length=255,
+        help_text="Bcrypt hashed password"
+    )
+    last_login = models.DateTimeField(
+        null=True,
+        blank=True,
+        help_text="Last successful login timestamp"
+    )
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'erp"."entity_auth'
+        verbose_name = "Entity Authentication"
+        verbose_name_plural = "Entity Authentications"
+
+    def __str__(self):
+        status = "active" if self.is_active else "inactive"
+        return f"Auth for {self.entity} ({status})"

constec/db/models/flow.py

@@ -0,0 +1,138 @@
+from django.db import models
+from .base import UUIDModel
+from .organization import Organization, OrganizationUser
+from .company import Company
+
+
+class FlowTemplate(UUIDModel):
+    """Global flow templates available to all companies.
+
+    Created by organization admins. Companies can use these
+    templates as-is or customize them.
+    """
+
+    organization = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name="flow_templates",
+        null=True,
+        blank=True,
+        help_text="Organization that owns this template (null for global)"
+    )
+
+    name = models.CharField(max_length=100)
+    description = models.TextField()
+    category = models.CharField(
+        max_length=50,
+        choices=[
+            ('finance', 'Finance & Accounting'),
+            ('customer_service', 'Customer Service'),
+            ('sales', 'Sales & CRM'),
+            ('general', 'General Purpose'),
+            ('custom', 'Custom'),
+        ]
+    )
+
+    graph_definition = models.JSONField(
+        help_text="Graph structure in JSON format with nodes and edges"
+    )
+
+    default_config = models.JSONField(
+        default=dict,
+        help_text="Default configuration for this template (LLM, tools, prompts)"
+    )
+
+    is_global = models.BooleanField(
+        default=False,
+        help_text="If true, all organizations can use this template"
+    )
+
+    version = models.CharField(max_length=20, default="1.0.0")
+    created_by = models.ForeignKey(
+        OrganizationUser,
+        on_delete=models.SET_NULL,
+        null=True,
+        related_name="created_templates"
+    )
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'constancia"."flow_templates'
+        unique_together = [['organization', 'name', 'version']]
+        indexes = [
+            models.Index(fields=['organization', 'is_global']),
+            models.Index(fields=['category', 'is_active']),
+        ]
+
+    def __str__(self):
+        global_tag = " [GLOBAL]" if self.is_global else ""
+        return f"{self.name} v{self.version}{global_tag}"
+
+
+class Flow(UUIDModel):
+    """Company-specific flow configuration.
+
+    Can either use a template or define custom graph.
+    Defines how the AI agent behaves for a specific company.
+    """
+
+    company = models.ForeignKey(
+        Company,
+        on_delete=models.CASCADE,
+        related_name="flows",
+    )
+
+    name = models.CharField(max_length=100)
+    description = models.TextField(blank=True, null=True)
+
+    template = models.ForeignKey(
+        FlowTemplate,
+        null=True,
+        blank=True,
+        on_delete=models.SET_NULL,
+        related_name="flows",
+        help_text="If set, uses template's graph. config overrides template defaults."
+    )
+
+    graph_definition = models.JSONField(
+        null=True,
+        blank=True,
+        help_text="Custom graph structure (only if not using template)"
+    )
+
+    config = models.JSONField(
+        default=dict,
+        help_text="Configuration that merges with template.default_config"
+    )
+
+    is_default = models.BooleanField(
+        default=False,
+        help_text="Whether this is the default flow for the company"
+    )
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'constancia"."flows'
+        unique_together = [['company', 'name']]
+        indexes = [
+            models.Index(fields=['company', 'is_default']),
+            models.Index(fields=['template', 'is_active']),
+        ]
+
+    def get_graph_definition(self):
+        """Returns the graph definition (from template or custom)."""
+        if self.template:
+            return self.template.graph_definition
+        return self.graph_definition
+
+    def get_merged_config(self):
+        """Merges template defaults with flow config."""
+        if self.template:
+            merged = {**self.template.default_config}
+            merged.update(self.config)
+            return merged
+        return self.config
+
+    def __str__(self):
+        default = " (Default)" if self.is_default else ""
+        return f"{self.company.name} - {self.name}{default}"

constec/db/models/group.py

@@ -0,0 +1,36 @@
+from django.db import models
+from .base import UUIDModel
+from .company import Company
+from .user import CompanyUser
+
+
+class UserGroup(UUIDModel):
+    """Hierarchical user groups within a company."""
+    company = models.ForeignKey(
+        Company,
+        on_delete=models.CASCADE,
+        related_name="user_groups",
+        null=True,
+        blank=True
+    )
+    name = models.CharField(max_length=100)
+    description = models.TextField(blank=True, null=True)
+    parent = models.ForeignKey(
+        'self',
+        on_delete=models.CASCADE,
+        related_name="sub_groups",
+        null=True,
+        blank=True
+    )
+    users = models.ManyToManyField(
+        CompanyUser,
+        related_name="groups"
+    )
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."user_groups'
+        unique_together = [['company', 'name']]
+
+    def __str__(self):
+        return f"{self.name}"

constec/db/models/module.py

@@ -0,0 +1,67 @@
+from django.db import models
+from .base import UUIDModel
+from .company import Company
+from .organization import Organization
+
+
+class Module(UUIDModel):
+    """Available modules in the platform."""
+    name = models.CharField(max_length=100)
+    slug = models.SlugField(max_length=100, null=True)
+    description = models.TextField(blank=True, null=True)
+    version = models.CharField(max_length=20)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."modules'
+
+    def __str__(self):
+        return f"{self.name}"
+
+
+class CompanyModule(UUIDModel):
+    """Modules enabled per company."""
+    company = models.ForeignKey(
+        Company,
+        on_delete=models.CASCADE,
+        related_name="company_modules",
+    )
+    module = models.ForeignKey(
+        Module,
+        on_delete=models.CASCADE,
+        related_name="company_modules",
+    )
+    is_enabled = models.BooleanField(default=True)
+    settings = models.JSONField(default=dict, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."company_modules'
+        unique_together = [['company', 'module']]
+
+    def __str__(self):
+        return f"{self.company.name} - {self.module.name}"
+
+
+class OrganizationModule(UUIDModel):
+    """Modules enabled per organization."""
+    organization = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name="organization_modules",
+    )
+    module = models.ForeignKey(
+        Module,
+        on_delete=models.CASCADE,
+        related_name="organization_modules",
+    )
+    is_enabled = models.BooleanField(default=True)
+    settings = models.JSONField(default=dict, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."organization_modules'
+        unique_together = [['organization', 'module']]
+
+    def __str__(self):
+        return f"{self.organization.name} - {self.module.name}"

constec/db/models/organization.py

@@ -0,0 +1,62 @@
+from django.db import models
+from .base import UUIDModel
+
+
+class Organization(UUIDModel):
+    """Platform-level tenant (e.g., Constec itself)."""
+    name = models.CharField(max_length=255)
+    slug = models.SlugField(max_length=100, unique=True)
+    description = models.TextField(blank=True, null=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."organizations'
+
+    def __str__(self):
+        return self.name
+
+
+class OrganizationRole(UUIDModel):
+    """Roles within an organization."""
+    organization = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name="organization_roles",
+        null=True,
+        blank=True
+    )
+    name = models.CharField(max_length=100)
+    description = models.TextField(blank=True, null=True)
+    permissions = models.JSONField(default=dict)
+    is_system_role = models.BooleanField(default=False)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."organization_roles'
+        unique_together = [['organization', 'name']]
+
+    def __str__(self):
+        return self.name
+
+
+class OrganizationUser(UUIDModel):
+    """Administrator users at organization level."""
+    organization = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name="users",
+    )
+    name = models.CharField(max_length=255)
+    email = models.EmailField(unique=True)
+    password_hash = models.CharField(max_length=255)
+    role = models.ForeignKey(
+        OrganizationRole,
+        on_delete=models.PROTECT
+    )
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."organization_users'
+
+    def __str__(self):
+        return f"{self.name} ({self.email})"

constec/db/models/person.py

@@ -0,0 +1,28 @@
+from django.db import models
+from .base import UUIDModel
+from .company import Company
+
+
+class Person(UUIDModel):
+    """Real person (customer, supplier, employee)."""
+    company = models.ForeignKey(
+        Company,
+        on_delete=models.CASCADE,
+        related_name="persons",
+    )
+    first_name = models.CharField(max_length=100)
+    last_name = models.CharField(max_length=100)
+    full_name = models.CharField(max_length=255)
+    metadata = models.JSONField(default=dict, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."persons'
+
+    def __str__(self):
+        return f"{self.full_name}"
+
+    def save(self, *args, **kwargs):
+        """Auto-generate full_name from first_name and last_name."""
+        self.full_name = f"{self.first_name} {self.last_name}"
+        super().save(*args, **kwargs)

constec/db/models/session.py

@@ -0,0 +1,89 @@
+from django.db import models
+from .base import UUIDModel
+from .company import Company
+from .person import Person
+from .flow import Flow
+
+
+class Session(UUIDModel):
+    """Conversation session between a user and the AI agent.
+
+    Tracks the conversation context including company, user, and permissions.
+    All MCP tools receive the session_id to know who is making the request.
+    """
+
+    company = models.ForeignKey(
+        Company,
+        on_delete=models.CASCADE,
+        related_name="sessions",
+        help_text="The company this session belongs to"
+    )
+    user = models.ForeignKey(
+        Person,
+        on_delete=models.CASCADE,
+        related_name="sessions",
+        help_text="The person chatting (can be employee or client)"
+    )
+    flow = models.ForeignKey(
+        Flow,
+        on_delete=models.PROTECT,
+        related_name="sessions",
+        help_text="AI flow configuration to use"
+    )
+
+    metadata = models.JSONField(
+        default=dict,
+        help_text="Session context (connection, role, etc.)"
+    )
+
+    ended_at = models.DateTimeField(null=True, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'constancia"."sessions'
+        indexes = [
+            models.Index(fields=['company', 'is_active']),
+            models.Index(fields=['user', 'is_active']),
+            models.Index(fields=['-created_at']),
+        ]
+
+    def __str__(self):
+        return f"Session {self.id} - {self.user} @ {self.company.name}"
+
+
+class Message(UUIDModel):
+    """Message in a conversation session.
+
+    Stores the conversation history between user and AI assistant.
+    """
+
+    ROLE_CHOICES = [
+        ('user', 'User'),
+        ('assistant', 'Assistant'),
+    ]
+
+    session = models.ForeignKey(
+        Session,
+        on_delete=models.CASCADE,
+        related_name="messages",
+    )
+    role = models.CharField(max_length=20, choices=ROLE_CHOICES)
+    content = models.TextField()
+
+    metadata = models.JSONField(
+        default=dict,
+        blank=True,
+        help_text="Additional message data: tool calls, errors, context, etc."
+    )
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'constancia"."messages'
+        ordering = ['created_at']
+        indexes = [
+            models.Index(fields=['session', 'created_at']),
+        ]
+
+    def __str__(self):
+        preview = self.content[:50] + "..." if len(self.content) > 50 else self.content
+        return f"{self.role}: {preview}"