oxutils 0.1.2__py3-none-any.whl → 0.1.6__py3-none-any.whl

oxutils/__init__.py

@@ -10,7 +10,7 @@ This package provides:
 - Custom exceptions
 """
 
-__version__ = "0.1.1"
+__version__ = "0.1.6"
 
 from oxutils.settings import oxi_settings
 from oxutils.conf import UTILS_APPS, AUDIT_MIDDLEWARE

oxutils/audit/settings.py

@@ -1,19 +1,4 @@
 # Oxiliere Audit settings
 
-AUDITLOG_DISABLE_REMOTE_ADDR = False
-AUDITLOG_MASK_TRACKING_FIELDS = (
-    "password",
-    "api_key",
-    "secret_token",
-    "token",
-)
-
-AUDITLOG_EXCLUDE_TRACKING_FIELDS = (
-    "created_at",
-    "updated_at",
-)
-
-CID_GENERATE = False
-
-AUDITLOG_CID_GETTER = "cid.locals.get_cid"
+AUDITLOG_CID_GETTER = "oxutils.audit.utils.get_request_id"
 AUDITLOG_LOGENTRY_MODEL =  "auditlog.LogEntry"

oxutils/audit/utils.py

@@ -0,0 +1,22 @@
+"""
+Utility functions for audit logging.
+"""
+import structlog
+
+
+def get_request_id():
+    """
+    Get the request_id from django-structlog context.
+    
+    This function retrieves the request_id that was set by 
+    django-structlog's RequestMiddleware and returns it for use
+    in auditlog's correlation ID field.
+    
+    Returns:
+        str: The request_id from the current request context, or None if not available.
+    """
+    try:
+        context = structlog.contextvars.get_contextvars()
+        return context.get('request_id')
+    except Exception:
+        return None

oxutils/conf.py

@@ -1,13 +1,11 @@
 UTILS_APPS = (
     'django_structlog',
     'auditlog',
-    'cid.apps.CidAppConfig',
     'django_celery_results',
     'oxutils.audit',
 )
 
 AUDIT_MIDDLEWARE = (
-    'cid.middleware.CidMiddleware',
-    'auditlog.middleware.AuditlogMiddleware',
     'django_structlog.middlewares.RequestMiddleware',
+    'auditlog.middleware.AuditlogMiddleware',
 )

oxutils/constants.py

@@ -0,0 +1,2 @@
+ORGANIZATION_QUERY_KEY = 'organization_id'
+ORGANIZATION_HEADER_KEY = 'X-Organization-ID'

oxutils/context/site_name_processor.py

@@ -0,0 +1,11 @@
+"""
+Context processor for site name
+"""
+
+def site_name(request):
+    from oxutils.settings import oxi_settings
+
+    return {
+        'site_name': oxi_settings.site_name,
+        'site_domain': oxi_settings.site_domain,
+    }

oxutils/currency/admin.py

@@ -0,0 +1,57 @@
+from django.contrib import admin
+from .models import CurrencyState, Currency
+
+
+class CurrencyInline(admin.TabularInline):
+    model = Currency
+    extra = 0
+    readonly_fields = ('id', 'code', 'rate')
+    can_delete = False
+    
+    def has_add_permission(self, request, obj=None):
+        return False
+
+
+@admin.register(CurrencyState)
+class CurrencyStateAdmin(admin.ModelAdmin):
+    list_display = ('id', 'source', 'currency_count', 'created_at', 'updated_at')
+    list_filter = ('source', 'created_at')
+    readonly_fields = ('id', 'created_at', 'updated_at')
+    search_fields = ('id', 'source')
+    ordering = ('-created_at',)
+    inlines = [CurrencyInline]
+    
+    def currency_count(self, obj):
+        return obj.currencies.count()
+    currency_count.short_description = 'Currencies'
+    
+    def has_add_permission(self, request):
+        return False
+    
+    def has_delete_permission(self, request, obj=None):
+        return request.user.is_superuser
+
+
+@admin.register(Currency)
+class CurrencyAdmin(admin.ModelAdmin):
+    list_display = ('id', 'code', 'rate', 'state_source', 'state_created_at')
+    list_filter = ('code', 'state__source', 'state__created_at')
+    readonly_fields = ('id', 'code', 'rate', 'state')
+    search_fields = ('code', 'state__id')
+    ordering = ('code',)
+    
+    def state_source(self, obj):
+        return obj.state.source
+    state_source.short_description = 'Source'
+    state_source.admin_order_field = 'state__source'
+    
+    def state_created_at(self, obj):
+        return obj.state.created_at
+    state_created_at.short_description = 'State Created'
+    state_created_at.admin_order_field = 'state__created_at'
+    
+    def has_add_permission(self, request):
+        return False
+    
+    def has_delete_permission(self, request, obj=None):
+        return request.user.is_superuser

oxutils/currency/apps.py

@@ -0,0 +1,7 @@
+from django.apps import AppConfig
+
+
+class CurrencyConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'oxutils.currency'
+    verbose_name = "Oxutils Currency"

oxutils/currency/controllers.py

@@ -0,0 +1,79 @@
+from django.http import HttpRequest
+from django.core.exceptions import ObjectDoesNotExist
+from ninja_extra import (
+    ControllerBase,
+    api_controller,
+    http_get,
+)
+from ninja_extra.pagination import (
+    paginate, PageNumberPaginationExtra, PaginatedResponseSchema
+)
+from ninja.errors import HttpError
+from uuid import UUID
+import structlog
+from oxutils.currency.models import CurrencyState
+from oxutils.currency.schemas import (
+    CurrencyStateSchema,
+    CurrencyStateDetailSchema,
+)
+
+
+logger = structlog.get_logger(__name__)
+
+
+@api_controller('/currency', tags=['Currency'], auth=None)
+class CurrencyController(ControllerBase):
+    
+    @http_get('/states', response=PaginatedResponseSchema[CurrencyStateSchema])
+    @paginate(PageNumberPaginationExtra, page_size=20)
+    def list_states(self, request: HttpRequest):
+        return CurrencyState.objects.all().order_by('-created_at')
+    
+    @http_get('/states/latest', response=CurrencyStateDetailSchema)
+    def get_latest_state(self, request: HttpRequest):
+        try:
+            state = CurrencyState.objects.latest()
+        except ObjectDoesNotExist:
+            logger.error("currency_state_not_found", message="No currency state found in database")
+            raise HttpError(404, "No currency state found in database")
+        
+        return {
+            'id': state.id,
+            'source': state.source,
+            'created_at': state.created_at,
+            'updated_at': state.updated_at,
+            'currencies': {c.code: float(c.rate) for c in state.currencies.all()}
+        }
+    
+    @http_get('/states/{state_id}', response=CurrencyStateDetailSchema)
+    def get_state(self, request: HttpRequest, state_id: UUID):
+        state = CurrencyState.objects.prefetch_related('currencies').get(id=state_id)
+        return {
+            'id': state.id,
+            'source': state.source,
+            'created_at': state.created_at,
+            'updated_at': state.updated_at,
+            'currencies': {c.code: float(c.rate) for c in state.currencies.all()}
+        }
+    
+    @http_get('/rates', response=dict[str, float])
+    def get_current_rates(self, request: HttpRequest):
+        try:
+            state = CurrencyState.objects.latest()
+        except ObjectDoesNotExist:
+            logger.error("currency_state_not_found", message="No currency state found in database")
+            raise HttpError(404, "No currency rates available")
+        
+        currencies = state.currencies.all()
+        return {c.code: float(c.rate) for c in currencies}
+    
+    @http_get('/rates/{code}', response=dict[str, float])
+    def get_rate_by_code(self, request: HttpRequest, code: str):
+        try:
+            state = CurrencyState.objects.latest()
+            currency = state.currencies.get(code=code.upper())
+        except ObjectDoesNotExist:
+            logger.error("currency_rate_not_found", code=code.upper())
+            raise HttpError(404, f"Currency rate for {code.upper()} not found")
+        
+        return {currency.code: float(currency.rate)}

oxutils/currency/enums.py

@@ -0,0 +1,7 @@
+from django.db.models import TextChoices
+
+
+class CurrencySource(TextChoices):
+    BCC = "bcc", "BCC"
+    OXR = "oxr", "Open Exchange Rates"
+

oxutils/currency/migrations/0001_initial.py

@@ -0,0 +1,41 @@
+# Generated by Django 5.2.9 on 2025-12-19 14:34
+
+import django.db.models.deletion
+import uuid
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='CurrencyState',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, help_text='Unique identifier for this record', primary_key=True, serialize=False)),
+                ('created_at', models.DateTimeField(auto_now_add=True, help_text='Date and time when this record was created')),
+                ('updated_at', models.DateTimeField(auto_now=True, help_text='Date and time when this record was last updated')),
+                ('source', models.CharField(choices=[('bcc', 'BCC'), ('oxr', 'Open Exchange Rates')], max_length=10)),
+            ],
+            options={
+                'abstract': False,
+            },
+        ),
+        migrations.CreateModel(
+            name='Currency',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, help_text='Unique identifier for this record', primary_key=True, serialize=False)),
+                ('code', models.CharField(max_length=10)),
+                ('rate', models.DecimalField(decimal_places=4, max_digits=10)),
+                ('state', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='currencies', to='currency.currencystate')),
+            ],
+            options={
+                'ordering': ['code'],
+                'indexes': [models.Index(fields=['code', 'state'], name='currency_cu_code_c68344_idx')],
+            },
+        ),
+    ]

oxutils/currency/models.py

@@ -0,0 +1,100 @@
+from typing import Optional
+from django.db import models
+from django.db import transaction
+import structlog
+from oxutils.models import (
+    UUIDPrimaryKeyMixin,
+    TimestampMixin,
+)
+from .enums import CurrencySource
+from .utils import load_rates
+
+
+
+logger = structlog.get_logger(__name__)
+
+
+AVAILABLES_CURRENCIES = [
+    "AOA",   
+    "AUD",   
+    "BIF",   
+    "CAD",   
+    "CHF",   
+    "CNY",   
+    "EUR",
+    "GBP",
+    "JPY",    
+    "RWF",    
+    "TZS",    
+    "UGX",    
+    "USD",    
+    "XAF",    
+    "XDR",    
+    "ZAR",
+    "ZMW"
+]
+
+
+class CurrencyStateManager(models.Manager):
+    def latest(self):
+        return self.get_queryset().prefetch_related("currencies").latest("created_at")
+
+class CurrencyState(UUIDPrimaryKeyMixin, TimestampMixin):
+    source = models.CharField(max_length=10, choices=CurrencySource.choices)
+    objects = CurrencyStateManager()
+    
+    @classmethod
+    def sync(cls) -> Optional['CurrencyState']:
+        rates, source = load_rates()
+        currencies = []
+
+        if not rates:
+            logger.error("currency_state_sync_failed", source=source)
+            raise ValueError("No rates found")
+
+        with transaction.atomic():
+            state = cls.objects.create(source=source)
+
+            for rate in rates:
+                currency = Currency(
+                    code=rate.currency,
+                    rate=rate.amount,
+                    state=state
+                )
+                currencies.append(currency)
+
+            Currency.objects.bulk_create(currencies)
+
+            logger.info("currency_state_synced", state=state.id, source=source)
+
+            return state
+
+
+class Currency(UUIDPrimaryKeyMixin):
+    code = models.CharField(max_length=10)
+    rate = models.DecimalField(max_digits=10, decimal_places=4)
+    state = models.ForeignKey(
+        CurrencyState, 
+        on_delete=models.CASCADE,
+        related_name="currencies"
+    )
+
+    class Meta:
+        ordering = ['code']
+        indexes = [
+            models.Index(fields=['code', 'state']),
+        ]
+
+    def __str__(self):
+        return f"{self.code} - {self.rate}"
+
+    def clean(self):
+        if self.code not in AVAILABLES_CURRENCIES:
+            raise ValueError(f"Invalid currency code: {self.code}")
+
+        if self.rate <= 0:
+            raise ValueError(f"Invalid currency rate: {self.rate}")
+
+    def save(self, *args, **kwargs):
+        self.clean()
+        super().save(*args, **kwargs)

oxutils/currency/schemas.py

@@ -0,0 +1,38 @@
+from ninja import Schema
+from datetime import datetime
+from uuid import UUID
+from decimal import Decimal
+
+
+class CurrencySchema(Schema):
+    code: str
+    rate: Decimal
+
+    class Config:
+        from_attributes = True
+
+
+class CurrencyStateSchema(Schema):
+    id: UUID
+    source: str
+    created_at: datetime
+    updated_at: datetime
+
+    class Config:
+        from_attributes = True
+
+
+class CurrencyStateDetailSchema(Schema):
+    id: UUID
+    source: str
+    created_at: datetime
+    updated_at: datetime
+    currencies: dict[str, float]
+
+    class Config:
+        from_attributes = True
+
+
+class CurrencyRateSchema(Schema):
+    code: str
+    rate: Decimal

oxutils/currency/tests.py

@@ -0,0 +1,3 @@
+from django.test import TestCase
+
+# Create your tests here.

oxutils/currency/utils.py

@@ -0,0 +1,69 @@
+import time
+from django.conf import settings
+from django.db import transaction
+from bcc_rates import BCCBankSource, OXRBankSource, SourceValue
+from oxutils.currency.enums import CurrencySource
+from oxutils.currency.schemas import CurrencyStateDetailSchema
+import structlog
+
+logger = structlog.get_logger(__name__)
+
+
+def load_rates() -> tuple[list[SourceValue], CurrencySource]:
+    max_retries = 3
+    retry_count = 0
+    
+    while retry_count < max_retries:
+        try:
+            bcc_source = BCCBankSource()
+            rates = bcc_source.sync(cache=True)
+            return rates, CurrencySource.BCC
+        except Exception as e:
+            retry_count += 1
+            if retry_count < max_retries:
+                time.sleep(1)
+            else:
+                if not getattr(settings, 'OXI_BCC_FALLBACK_ON_OXR', False):
+                    raise Exception(f"Failed to load rates from BCC: {str(e)}")
+                break
+    
+    try:
+        oxr_source = OXRBankSource()
+        rates = oxr_source.sync(cache=True)
+        return rates, CurrencySource.OXR
+    except Exception as e:
+        raise Exception(f"Failed to load rates from both BCC and OXR: {str(e)}")
+
+@transaction.atomic
+def update_rates(state: CurrencyStateDetailSchema):
+    from oxutils.currency.models import CurrencyState, Currency 
+
+    if CurrencyState.objects.filter(id=state.id).exists():
+        logger.info("currency_state_exists", id=state.id)
+        return
+
+    if not len(state.currencies.keys()):
+        logger.info("currency_state_no_currencies", id=state.id)
+        return
+
+    _state = CurrencyState.objects.create(
+        id=state.id,
+        source=state.source,
+        created_at=state.created_at,
+        updated_at=state.updated_at,
+    )
+
+    currencies = []
+
+    for key, value in state.currencies.items():
+        currencies.append(
+            Currency(
+                code=key,
+                rate=value,
+                state=_state
+            )
+        )
+
+    Currency.objects.bulk_create(currencies)
+
+    logger.info("currency_state_updated", id=state.id)

oxutils/functions.py

@@ -6,12 +6,15 @@ from ninja_extra.exceptions import ValidationError
 
 
 def get_absolute_url(url: str, request=None):
+    if url.startswith('http'):
+        return url
+
     if request:
         # Build absolute URL using request
         return request.build_absolute_uri(url)
     else:
-        # Fallback: build URL using MEDIA_URL and domain
-        base_url = getattr(settings, 'SITE_URL', 'http://localhost:8000')
+        # Fallback: build URL using SITE_DOMAIN and domain
+        base_url = getattr(settings, 'SITE_DOMAIN', 'http://localhost:8000')
         return urljoin(base_url, url)
 
 

oxutils/logger/receivers.py

@@ -2,7 +2,6 @@ from django.contrib.sites.shortcuts import RequestSite
 from django.dispatch import receiver
 import structlog
 from django_structlog import signals
-from cid.locals import get_cid
 from oxutils.settings import oxi_settings
 
 
@@ -12,7 +11,6 @@ def bind_domain(request, logger, **kwargs):
     current_site = RequestSite(request)
     structlog.contextvars.bind_contextvars(
         domain=current_site.domain,
-        cid=get_cid(),
         user_id=str(request.user.pk),
         service=oxi_settings.service_name
     )

oxutils/oxiliere/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

oxutils/oxiliere/apps.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class OxiliereConfig(AppConfig):
+    default_auto_field = 'django.db.models.BigAutoField'
+    name = 'oxiliere'

oxutils/oxiliere/cacheops.py

@@ -0,0 +1,7 @@
+from  django.db import connection
+
+
+def cacheops_prefix(query):
+    if connection.schema_name:
+        return '%s:' % connection.schema_name
+    return 'default:'

oxutils/oxiliere/caches.py

@@ -0,0 +1,33 @@
+from cacheops import cached_as, cached
+from oxutils.oxiliere.models import Tenant, TenantUser
+from django_tenants.utils import get_tenant_model
+
+
+TenantModel = get_tenant_model()
+
+
+@cached_as(TenantModel, timeout=60*15)
+def get_tenant_by_oxi_id(oxi_id: str):
+    return TenantModel.objects.get(oxi_id=oxi_id)
+
+
+@cached_as(TenantModel, timeout=60*15)
+def get_tenant_by_schema_name(schema_name: str) -> Tenant:
+    return TenantModel.objects.get(schema_name=schema_name)
+
+
+@cached_as(TenantUser, timeout=60*15)
+def get_tenant_user(oxi_org_id: str, oxi_user_id: str):
+    return TenantUser.objects.get(
+        tenant__oxi_id=oxi_org_id,
+        user__oxi_id=oxi_user_id
+    )
+
+@cached(timeout=60*15)
+def get_system_tenant():
+    from oxutils.oxiliere.utils import oxid_to_schema_name
+
+    system_schema_name = oxid_to_schema_name(
+        getattr(settings, 'OXI_SYSTEM_TENANT', 'tenant_oxisystem')
+    )
+    return get_tenant_model().objects.get(schema_name=system_schema_name)

oxutils/oxiliere/controllers.py

@@ -0,0 +1,36 @@
+from ninja_extra import (
+    api_controller,
+    ControllerBase,
+    http_post,
+)
+from .permissions import OxiliereServicePermission
+from .schemas import CreateTenantSchema
+from oxutils.mixins.schemas import ResponseSchema
+
+
+@api_controller(
+    '/setup',
+    tags=['Setup'],
+    auth=None,
+    permissions=[
+        OxiliereServicePermission(),
+    ]
+)
+class SetupController(ControllerBase):
+    
+    @http_post(
+        '/init',
+        response=ResponseSchema,
+    )
+    def init(self, payload: CreateTenantSchema):
+        try:
+            payload.create_tenant()
+        except Exception as e:
+            return ResponseSchema(
+                code='initialization_failed',
+                detail=str(e)
+            )
+        return ResponseSchema(
+            code='success',
+            detail='Tenant initialized successfully'
+        )

oxutils/oxiliere/enums.py

@@ -0,0 +1,10 @@
+from django.db.models import TextChoices
+
+
+
+class TenantStatus(TextChoices):
+    ACTIVE = 'active'
+    INACTIVE = 'inactive'
+    SUSPENDED = 'suspended'
+    DELETED = 'deleted'
+    REMOVED = 'removed'