constec 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

constec/db/models/company.py

@@ -0,0 +1,36 @@
+from django.db import models
+from django.core.exceptions import ValidationError
+from .base import UUIDModel
+from .organization import Organization
+
+
+class Company(UUIDModel):
+    """Client company, belongs to an Organization."""
+    organization = models.ForeignKey(
+        Organization,
+        on_delete=models.CASCADE,
+        related_name="companies",
+    )
+    name = models.CharField(max_length=255)
+    legal_name = models.CharField(max_length=255)
+    slug = models.SlugField(max_length=100, unique=True)
+    parent_company = models.ForeignKey(
+        'self',
+        null=True,
+        blank=True,
+        on_delete=models.CASCADE,
+        related_name='children'
+    )
+    website = models.URLField(blank=True, null=True)
+    is_active = models.BooleanField(default=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."companies'
+
+    def __str__(self):
+        return self.name
+
+    def clean(self):
+        if self.parent_company == self:
+            raise ValidationError('A company cannot be its own parent')

constec/db/models/contact.py

@@ -0,0 +1,68 @@
+from django.db import models
+from .base import UUIDModel
+from .person import Person
+
+
+class ContactType(UUIDModel):
+    """Types of contact (email, phone, etc)."""
+    name = models.CharField(max_length=50)
+    description = models.TextField(blank=True, null=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."contact_types'
+
+    def __str__(self):
+        return f"{self.name}"
+
+
+class Contact(UUIDModel):
+    """Contact value."""
+    type = models.ForeignKey(
+        ContactType,
+        on_delete=models.CASCADE,
+        related_name="contacts",
+    )
+    value = models.CharField(max_length=255)
+    metadata = models.JSONField(default=dict, blank=True)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."contacts'
+
+    def __str__(self):
+        return f"{self.value} ({self.type.name})"
+
+
+class PersonContact(UUIDModel):
+    """Person-contact relationship."""
+    person = models.ForeignKey(
+        Person,
+        on_delete=models.CASCADE,
+        related_name="person_contacts",
+    )
+    contact = models.ForeignKey(
+        Contact,
+        on_delete=models.CASCADE,
+        related_name="person_contacts",
+    )
+    is_primary = models.BooleanField(default=False)
+
+    class Meta:
+        app_label = 'constec_db'
+        db_table = 'core"."person_contacts'
+        unique_together = [['person', 'contact']]
+
+    def __str__(self):
+        return f"{self.person.full_name} - {self.contact.value} ({self.contact.type.name})"
+
+    def save(self, *args, **kwargs):
+        """Remove is_primary from other contacts of the same type for this person."""
+        if self.is_primary:
+            PersonContact.objects.filter(
+                person=self.person,
+                contact__type=self.contact.type,
+                is_primary=True
+            ).exclude(pk=self.pk).update(is_primary=False)
+
+        super().save(*args, **kwargs)

constec/db/models/erp.py

@@ -0,0 +1,109 @@
+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)
+    created_at = models.DateTimeField(auto_now_add=True, null=True)
+    updated_at = models.DateTimeField(auto_now=True, null=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"
+    )
+    is_active = models.BooleanField(default=True)
+    metadata = models.JSONField(default=dict, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=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()
+    is_active = models.BooleanField(default=True)
+    last_tested_at = models.DateTimeField(null=True, blank=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=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,113 @@
+from django.db import models
+from .base import UUIDModel
+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.
+    """
+    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"'
+        unique_together = [['system', 'role', 'external_id']]
+        indexes = [
+            models.Index(fields=['cuit']),
+            models.Index(fields=['system', 'cuit']),
+        ]
+
+    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"
+    )
+    is_active = models.BooleanField(
+        default=True,
+        help_text="Whether this account can authenticate"
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    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,145 @@
+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"
+    )
+    is_active = models.BooleanField(default=True)
+
+    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"
+    )
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    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_active = models.BooleanField(default=True)
+    is_default = models.BooleanField(
+        default=False,
+        help_text="Whether this is the default flow for the company"
+    )
+
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+
+    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 User
+
+
+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(
+        User,
+        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,43 @@
+from django.db import models
+from .base import UUIDModel
+from .company import Company
+
+
+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)
+    is_active = models.BooleanField(default=True)
+
+    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}"

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)