django-ledger 0.5.5.4__py3-none-any.whl → 0.5.6.0__py3-none-any.whl

django_ledger/__init__.py

@@ -9,7 +9,7 @@ Contributions to this module:
 default_app_config = 'django_ledger.apps.DjangoLedgerConfig'
 
 """Django Ledger"""
-__version__ = '0.5.5.4'
+__version__ = '0.5.6.0'
 __license__ = 'GPLv3 License'
 
 __author__ = 'Miguel Sanda'

django_ledger/admin/__init__.py

@@ -0,0 +1,10 @@
+from django.contrib import admin
+
+from django_ledger.admin.coa import ChartOfAccountsModelAdmin
+from django_ledger.admin.entity import EntityModelAdmin
+from django_ledger.admin.ledger import LedgerModelAdmin
+from django_ledger.models import EntityModel, ChartOfAccountModel, LedgerModel
+
+admin.site.register(EntityModel, EntityModelAdmin)
+admin.site.register(ChartOfAccountModel, ChartOfAccountsModelAdmin)
+admin.site.register(LedgerModel, LedgerModelAdmin)

django_ledger/admin/coa.py

@@ -0,0 +1,135 @@
+from django.contrib.admin import TabularInline, ModelAdmin
+from django.db.models import Count
+from django.forms import ModelForm, BooleanField, BaseInlineFormSet
+
+from django_ledger.models.accounts import AccountModel
+from django_ledger.models.coa import ChartOfAccountModel
+from django_ledger.models.entity import EntityModel
+
+
+class AccountModelInLineForm(ModelForm):
+    role_default = BooleanField(initial=False, required=False)
+
+    class Meta:
+        model = AccountModel
+        fields = []
+
+
+class AccountModelInLineFormSet(BaseInlineFormSet):
+
+    def save_new(self, form, commit=True):
+        setattr(form.instance, self.fk.name, self.instance)
+        if commit:
+            account_model = AccountModel.add_root(
+                instance=super().save_new(form, commit=False)
+            )
+            return account_model
+        return super().save_new(form, commit=False)
+
+
+class AccountModelInLine(TabularInline):
+    extra = 0
+    form = AccountModelInLineForm
+    formset = AccountModelInLineFormSet
+    show_change_link = True
+    exclude = [
+        'path',
+        'depth',
+        'numchild'
+    ]
+    model = AccountModel
+    fieldsets = [
+        ('', {
+            'fields': [
+                'role',
+                'balance_type',
+                'code',
+                'name',
+                'role_default',
+                'locked',
+                'active'
+            ]
+        })
+    ]
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request)
+        return qs.not_coa_root()
+
+
+class ChartOfAccountsAdminForm(ModelForm):
+    assign_as_default = BooleanField(initial=False, required=False)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        if self.instance.is_default():
+            self.fields['assign_as_default'].initial = True
+            self.fields['assign_as_default'].disabled = True
+
+    def save(self, commit=True):
+        if commit:
+            if self.cleaned_data['assign_as_default']:
+                entity_model: EntityModel = self.instance.entity
+                entity_model.default_coa = self.instance
+                entity_model.save(update_fields=[
+                    'default_coa'
+                ])
+        return super().save(commit=commit)
+
+
+class ChartOfAccountsInLine(TabularInline):
+    form = ChartOfAccountsAdminForm
+    model = ChartOfAccountModel
+    extra = 0
+    show_change_link = True
+    fields = [
+        'name',
+        'locked',
+        'assign_as_default'
+    ]
+
+
+class ChartOfAccountsModelAdmin(ModelAdmin):
+    list_filter = [
+        'entity__name',
+        'locked'
+    ]
+    list_display = [
+        'entity_name',
+        'name',
+        'slug',
+        'locked',
+        'account_model_count'
+    ]
+    search_fields = [
+        'slug',
+        'entity__name'
+    ]
+    list_display_links = ['name']
+    fields = [
+        'name',
+        'locked',
+        'description',
+    ]
+    inlines = [
+        AccountModelInLine
+    ]
+
+    class Meta:
+        model = ChartOfAccountModel
+
+    def entity_name(self, obj):
+        return obj.entity.name
+
+    def get_queryset(self, request):
+        qs = ChartOfAccountModel.objects.for_user(user_model=request.user)
+        ordering = self.get_ordering(request)
+        if ordering:
+            qs = qs.order_by(*ordering)
+        qs = qs.select_related('entity').annotate(Count('accountmodel'))
+        return qs
+
+    def account_model_count(self, obj):
+        return obj.accountmodel__count
+
+    account_model_count.short_description = 'Accounts'

django_ledger/admin/entity.py

@@ -0,0 +1,199 @@
+from datetime import timedelta
+from uuid import uuid4
+
+from django.contrib.admin import TabularInline, ModelAdmin
+from django.db.models import Count
+from django.forms import BaseInlineFormSet
+from django.urls import reverse
+from django.utils.html import format_html
+from django.utils.timezone import localtime
+
+from django_ledger.admin.coa import ChartOfAccountsInLine
+from django_ledger.models import EntityUnitModel, ItemTransactionModel, TransactionModel
+from django_ledger.models.entity import EntityModel, EntityManagementModel
+
+
+class EntityManagementInLine(TabularInline):
+    model = EntityManagementModel
+    extra = 1
+    fields = [
+        'user'
+    ]
+
+
+class EntityUnitModelInLineFormSet(BaseInlineFormSet):
+
+    def save_new(self, form, commit=True):
+        setattr(form.instance, self.fk.name, self.instance)
+        if commit:
+            unit_model = EntityUnitModel.add_root(
+                instance=super().save_new(form, commit=False)
+            )
+            return unit_model
+        return super().save_new(form, commit=False)
+
+
+class EntityUnitModelInLine(TabularInline):
+    model = EntityUnitModel
+    formset = EntityUnitModelInLineFormSet
+    extra = 0
+    readonly_fields = [
+        'slug'
+    ]
+    fields = [
+        'slug',
+        'name',
+        'document_prefix',
+        'active',
+        'hidden'
+    ]
+
+
+class EntityModelAdmin(ModelAdmin):
+    list_display = [
+        'slug',
+        'name',
+        'accrual_method',
+        'last_closing_date',
+        'hidden',
+        'get_coa_count',
+        'add_ledger_link',
+        'balance_sheet_link',
+        'income_statement_link',
+        'cash_flow_statement_link'
+    ]
+    readonly_fields = [
+        'depth',
+        'path',
+        'numchild',
+        'last_closing_date',
+        'default_coa'
+    ]
+    fieldsets = [
+        (
+            'Entity Information', {
+                'fields': [
+                    'name',
+                    'admin',
+                    'fy_start_month',
+                    'accrual_method',
+                    'hidden',
+                    'picture'
+                ]
+            }
+        ),
+        (
+            'Contact Information', {
+                'fields': [
+                    'address_1',
+                    'address_2',
+                    'city',
+                    'state',
+                    'zip_code',
+                    'email',
+                    'website',
+                    'phone'
+                ]
+            }
+        ),
+        (
+            'Chart of Accounts', {
+                'fields': [
+                    'default_coa'
+                ]
+            }
+        )
+    ]
+    inlines = [
+        ChartOfAccountsInLine,
+        EntityUnitModelInLine,
+        EntityManagementInLine
+    ]
+    actions = [
+        'add_code_of_accounts',
+        'populate_random_data'
+    ]
+
+    class Meta:
+        model = EntityModel
+
+    def get_queryset(self, request):
+        qs = super().get_queryset(request=request)
+        qs = qs.annotate(Count('chartofaccountmodel'))
+        if request.user.is_superuser:
+            return qs
+        return qs.for_user(user_model=request.user)
+
+    def add_ledger_link(self, obj):
+        add_ledger_url = reverse('admin:django_ledger_ledgermodel_add')
+        return format_html('<a class="addlink" href="{url}?entity_slug={slug}">Add Ledger</a>',
+                           url=add_ledger_url,
+                           slug=obj.slug)
+
+    def balance_sheet_link(self, obj: EntityModel):
+        add_ledger_url = reverse(
+            viewname='django_ledger:entity-bs',
+            kwargs={
+                'entity_slug': obj.slug
+            })
+        return format_html('<a class="viewlink" href="{url}">View</a>',
+                           url=add_ledger_url,
+                           slug=obj.slug)
+
+    balance_sheet_link.short_description = 'Balance Sheet'
+
+    def income_statement_link(self, obj: EntityModel):
+        add_ledger_url = reverse(
+            viewname='django_ledger:entity-ic',
+            kwargs={
+                'entity_slug': obj.slug
+            })
+        return format_html('<a class="viewlink" href="{url}">View</a>',
+                           url=add_ledger_url,
+                           slug=obj.slug)
+
+    income_statement_link.short_description = 'P&L'
+
+    def cash_flow_statement_link(self, obj: EntityModel):
+        add_ledger_url = reverse(
+            viewname='django_ledger:entity-cf',
+            kwargs={
+                'entity_slug': obj.slug
+            })
+        return format_html('<a class="viewlink" href="{url}">View</a>',
+                           url=add_ledger_url,
+                           slug=obj.slug)
+
+    cash_flow_statement_link.short_description = 'Cash Flow'
+
+    def add_code_of_accounts(self, request, queryset):
+        for entity_model in queryset:
+            entity_model.create_chart_of_accounts(
+                coa_name=f'{entity_model.name} CoA {localtime().isoformat()}',
+                commit=True,
+                assign_as_default=False
+            )
+
+    def populate_random_data(self, request, queryset):
+        for entity_model in queryset:
+            start_date = localtime() - timedelta(days=180)
+            entity_model.populate_random_data(
+                start_date=start_date,
+                days_forward=180,
+                tx_quantity=25)
+
+    def get_coa_count(self, obj):
+        return obj.chartofaccountmodel__count
+
+    get_coa_count.short_description = 'CoA Count'
+
+    def save_model(self, request, obj, form, change):
+        if not change:
+            if obj.uuid is None:
+                obj.uuid = uuid4()
+            EntityModel.add_root(instance=obj)
+            return
+        super().save_model(request, obj, form, change)
+
+    def has_delete_permission(self, request, obj=None):
+        return False

django_ledger/admin/ledger.py

@@ -0,0 +1,283 @@
+from django.contrib import messages
+from django.contrib.admin import ModelAdmin, TabularInline
+from django.db.models import Count
+from django.forms import BaseInlineFormSet
+from django.shortcuts import get_object_or_404
+from django.utils.html import format_html
+
+from django_ledger.models import (
+    LedgerModel, JournalEntryModel, EntityModel,
+    LedgerModelValidationError
+)
+
+
+class JournalEntryModelInLineFormSet(BaseInlineFormSet):
+
+    def __init__(self, *args, **kwargs):
+        self.ledger_model: LedgerModel = kwargs['instance']
+        self.entity_model = self.ledger_model.entity
+        super().__init__(*args, **kwargs)
+
+    def add_fields(self, form, index):
+        super().add_fields(form=form, index=index)
+        form.fields['entity_unit'].queryset = self.entity_model.entityunitmodel_set.all()
+
+
+class JournalEntryModelInLine(TabularInline):
+    extra = 0
+    fields = [
+        'timestamp',
+        'description',
+        'entity_unit',
+        'posted',
+        'locked',
+        'activity',
+        'origin',
+        'txs_count',
+        'view_txs_link',
+        'edit_txs_link'
+    ]
+    readonly_fields = [
+        'posted',
+        'locked',
+        'origin',
+        'activity',
+        'txs_count',
+        'view_txs_link',
+        'edit_txs_link'
+    ]
+    model = JournalEntryModel
+    formset = JournalEntryModelInLineFormSet
+
+    def get_queryset(self, request):
+        qs = self.model.objects.for_user(request.user)
+        ordering = self.get_ordering(request)
+        if ordering:
+            qs = qs.order_by(*ordering)
+        return qs.annotate(
+            txs_count=Count('transactionmodel')
+        ).select_related(
+            'ledger',
+            'ledger__entity'
+        )
+
+    def txs_count(self, obj):
+        return obj.txs_count
+
+    txs_count.short_description = 'Transactions'
+
+    def has_change_permission(self, request, obj=None):
+        if obj:
+            return all([
+                not obj.is_locked(),
+                super().has_change_permission(request, obj)
+            ])
+        return super().has_change_permission(request, obj)
+
+    def has_delete_permission(self, request, obj=None):
+        if obj:
+            return all([
+                obj.can_delete(),
+                super().has_delete_permission(request, obj)
+            ])
+        return super().has_delete_permission(request, obj)
+
+    def view_txs_link(self, obj: JournalEntryModel):
+        detail_url = obj.get_detail_url()
+        return format_html(
+            format_string='<a class="viewlink" target="_blank" href="{url}">View Txs</a>',
+            url=detail_url
+        )
+
+    def edit_txs_link(self, obj: JournalEntryModel):
+        detail_url = obj.get_detail_txs_url()
+        next_url = None
+        return format_html(
+            format_string='<a class="changelink" target="_blank" href="{url}">Edit Txs</a>',
+            url=detail_url
+        )
+
+
+class LedgerModelAdmin(ModelAdmin):
+    readonly_fields = [
+        'entity',
+        'posted',
+        'locked'
+    ]
+    list_filter = [
+        'posted',
+        'locked',
+        'entity__name'
+    ]
+    list_display = [
+        'name',
+        'is_posted',
+        'is_locked',
+        'is_extended',
+        'journal_entry_count',
+        'earliest_journal_entry'
+    ]
+    actions = [
+        'post',
+        'unpost',
+        'lock',
+        'unlock'
+    ]
+    inlines = [
+        JournalEntryModelInLine
+    ]
+
+    def get_queryset(self, request):
+        qs = LedgerModel.objects.for_user(user_model=request.user)
+        ordering = self.get_ordering(request)
+        if ordering:
+            qs = qs.order_by(*ordering)
+        return qs.select_related('entity')
+
+    def get_inlines(self, request, obj):
+        if obj is None:
+            return []
+        return super().get_inlines(request, obj)
+
+    def get_fieldsets(self, request, obj=None):
+        if obj is None:
+            return [
+                ('', {
+                    'fields': [
+                        'name',
+                        'hidden',
+                        'additional_info'
+                    ]
+                })
+            ]
+        return [
+            ('', {
+                'fields': [
+                    'entity',
+                    'name',
+                    'hidden',
+                    'additional_info'
+                ]
+            })
+        ]
+
+    def get_entity_model(self, request) -> EntityModel:
+        entity_slug = request.GET.get('entity_slug')
+        entity_model_qs = EntityModel.objects.for_user(user_model=request.user)
+        entity_model = get_object_or_404(entity_model_qs, slug__exact=entity_slug)
+        return entity_model
+
+    def has_add_permission(self, request):
+        if request.GET.get('entity_slug') is not None:
+            return True
+        return False
+
+    def add_view(self, request, form_url="", extra_context=None):
+        entity_model = self.get_entity_model(request)
+        extra_context = {
+            'entity_model': entity_model,
+            'title': f'Add Ledger: {entity_model.name}'
+        }
+        return super().add_view(request, form_url="", extra_context=extra_context)
+
+    def is_locked(self, obj):
+        return obj.is_locked()
+
+    is_locked.boolean = True
+
+    def is_posted(self, obj):
+        return obj.is_posted()
+
+    is_posted.boolean = True
+
+    def is_extended(self, obj):
+        return obj.has_wrapped_model()
+
+    is_extended.boolean = True
+
+    # ACTIONS....
+    def post(self, request, queryset):
+        for obj in queryset:
+            try:
+                obj.post(raise_exception=True, commit=False)
+            except LedgerModelValidationError as e:
+                messages.error(
+                    request=request,
+                    message=e.message
+                )
+        queryset.bulk_update(
+            objs=queryset,
+            fields=[
+                'posted',
+                'updated'
+            ])
+
+    def lock(self, request, queryset):
+        for obj in queryset:
+            try:
+                obj.lock(raise_exception=True, commit=False)
+            except LedgerModelValidationError as e:
+                messages.error(
+                    request=request,
+                    message=e.message
+                )
+
+        queryset.bulk_update(
+            objs=queryset,
+            fields=[
+                'locked',
+                'updated'
+            ])
+
+    def unpost(self, request, queryset):
+        for obj in queryset:
+            try:
+                obj.unpost(raise_exception=True, commit=False)
+            except LedgerModelValidationError as e:
+                messages.error(
+                    request=request,
+                    message=e.message
+                )
+        queryset.bulk_update(
+            objs=queryset,
+            fields=[
+                'posted',
+                'updated'
+            ])
+
+    def unlock(self, request, queryset):
+        for obj in queryset:
+            try:
+                obj.unlock(raise_exception=True, commit=False)
+            except LedgerModelValidationError as e:
+                messages.error(
+                    request=request,
+                    message=e.message
+                )
+
+        queryset.bulk_update(
+            objs=queryset,
+            fields=[
+                'locked',
+                'updated'
+            ])
+
+    def journal_entry_count(self, obj):
+        return obj.journal_entries__count
+
+    def earliest_journal_entry(self, obj):
+        return obj.earliest_timestamp
+
+    def save_model(self, request, obj: LedgerModel, form, change):
+        if not change:
+            entity_model = self.get_entity_model(request)
+            obj.entity = entity_model
+        return super().save_model(
+            request=request,
+            obj=obj,
+            form=form,
+            change=change
+        )
+
+    class Meta:
+        model = LedgerModel

django_ledger/forms/entity.py

@@ -20,15 +20,6 @@ class EntityModelCreateForm(ModelForm):
     default_coa = BooleanField(required=False, initial=False, label=_('Populate Default CoA'))
     activate_all_accounts = BooleanField(required=False, initial=False, label=_('Activate All Accounts'))
     generate_sample_data = BooleanField(required=False, initial=False, label=_('Fill With Sample Data?'))
-    tx_quantity = IntegerField(required=True, initial=50, label=_('Number of Transaction Loops'),
-                               validators=[
-                                   MinValueValidator(limit_value=0),
-                                   MaxValueValidator(limit_value=100)
-                               ],
-                               widget=TextInput(attrs={
-                                   'class': DJANGO_LEDGER_FORM_INPUT_CLASSES
-                               }))
-
 
     def clean_name(self):
         name = self.cleaned_data.get('name')
@@ -200,7 +191,8 @@ class EntityModelUpdateForm(ModelForm):
                     'placeholder': _('Website...')
                 }
             ),
-            'fy_start_month': Select(attrs={
-                'class': 'input'
-            })
+            'fy_start_month': Select(
+                attrs={
+                    'class': 'input'
+                })
         }

django_ledger/forms/ledger.py

@@ -1,4 +1,6 @@
+from django.core.exceptions import ValidationError
 from django.forms import ModelForm, TextInput, Select
+from django.utils.translation import gettext_lazy as _
 
 from django_ledger.models.ledger import LedgerModel
 from django_ledger.settings import DJANGO_LEDGER_FORM_INPUT_CLASSES
@@ -11,10 +13,19 @@ class LedgerModelCreateForm(ModelForm):
         self.ENTITY_SLUG: str = entity_slug
         self.USER_MODEL = user_model
 
+    def validate_unique(self):
+        exclude = self._get_validation_exclusions()
+        exclude.remove('entity')
+        try:
+            self.instance.validate_unique(exclude=exclude)
+        except ValidationError as e:
+            self._update_errors(e)
+
     class Meta:
         model = LedgerModel
         fields = [
             'name',
+            'ledger_xid'
         ]
         widgets = {
             'name': TextInput(
@@ -22,6 +33,14 @@ class LedgerModelCreateForm(ModelForm):
                     'class': DJANGO_LEDGER_FORM_INPUT_CLASSES
                 }
             ),
+            'ledger_xid': TextInput(
+                attrs={
+                    'class': DJANGO_LEDGER_FORM_INPUT_CLASSES
+                }
+            ),
+        }
+        labels = {
+            'ledger_xid': _('Ledger External ID')
         }