finance-sdk 1.0.3__py3-none-any.whl

finance_sdk/__init__.py

@@ -0,0 +1,2 @@
+default_app_config = 'finance_sdk.apps.FinanceSdkConfig'
+__version__ = '1.0.2'

finance_sdk/admin.py

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

finance_sdk/apps.py

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

finance_sdk/enums.py

@@ -0,0 +1,52 @@
+
+class Type:
+        ENTRY = "E"
+        OUT = "O"
+        AUTOMATIC_PAYMENT = "AP"
+        PAID_ENTRY = 'PE'
+
+        CHOICES = (
+               (ENTRY , "Entry"),
+               (OUT , "Out"),
+               (AUTOMATIC_PAYMENT, "Automatic Payment"),
+               (PAID_ENTRY , "Paid entry")
+        )
+
+
+        
+class RegistryClassification:
+        VARIABLE = "variable"
+        FIX = "fix"
+        INVESTIMENT = "investiment"
+
+        CHOICES = (
+               (VARIABLE, "variable"),
+               (FIX , "fix"),
+               (INVESTIMENT, "investiment"),
+        )
+
+
+class Frequency:
+        NONE = 0  
+        WEEK = 7  
+        BIWEEK = 15  
+        MONTH = 30  
+        YEAR = 365  
+
+        CHOICES = (
+               (NONE, "None"),
+               (WEEK , "Week"),
+               (BIWEEK, "Biweek"),
+               (BIWEEK, "Biweek"),
+        )
+
+        @staticmethod
+        def get_frequency(frequency: int):
+            mapping = {
+                Frequency.WEEK : 2,
+                Frequency.BIWEEK : 3,
+                Frequency.MONTH : 4,
+                Frequency.YEAR : 5,
+                 
+            }
+            return mapping.get(frequency, 1)

finance_sdk/models/accounts.py

@@ -0,0 +1,41 @@
+from django.db import models
+
+from models import bank
+
+class Account(models.Model):
+    name = models.CharField(max_length=200, blank=False, null=False)
+    bank = models.ForeignKey(bank, on_delete=models.PROTECT)
+    deactivate = models.BooleanField(default=False, blank=False, null=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    client_app = models.JSONField()
+
+    def __str__(self):
+        return self.name + " - " + self.bank.name
+
+
+class AccountPermission(models.Model):
+    account = models.ForeignKey(Account, on_delete=models.CASCADE)
+    employee = models.JSONField()
+    deactivate = models.BooleanField(default=False, blank=False, null=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    client_app = models.JSONField()
+
+    def __str__(self):
+        return "Account: %s | %s" % (self.account, self.employee)
+
+    @staticmethod
+    def get_account(user_id, client_app):
+        accounts = Account.objects.filter(
+            id__in=[
+                AccountPermission.objects.filter(
+                    employee__user_id=user_id,
+                    client_app_id=client_app,
+                    deactivate=False,
+                    account__bank__deactivate=False,
+                ).values_list("account_id")
+            ]
+        )
+
+        return accounts

finance_sdk/models/bank.py

@@ -0,0 +1,11 @@
+from django.db import models
+
+class Bank(models.Model):
+    name = models.CharField(max_length=200, blank=False, null=False)
+    deactivate = models.BooleanField(default=False, blank=False, null=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    client_app = models.JSONField()
+
+    def __str__(self):
+        return self.name

finance_sdk/models/category.py

@@ -0,0 +1,17 @@
+from django.db import models
+
+class Category(models.Model):
+    name = models.CharField("Nome", max_length=200, blank=False, null=False)
+    principal_category = models.ForeignKey(
+        "self", on_delete=models.PROTECT, blank=True, null=True
+    )
+    is_entry = models.BooleanField(default=True, blank=False, null=False)
+    is_out = models.BooleanField(default=True, blank=False, null=False)
+    deactivate = models.BooleanField(default=False, blank=False, null=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    client_app = models.JSONField()
+
+
+    def __str__(self):
+        return self.name

finance_sdk/models/entry.py

@@ -0,0 +1,53 @@
+from django.db import models
+
+from category import Category
+from payment import PaymentMethod
+from accounts import Account
+
+from enums import Frequency, Type, RegistryClassification
+
+class Entry(models.Model):
+    due_date = models.DateField(blank=False)
+    payment_date = models.DateField(blank=True, null=True)
+    description = models.TextField("Description", blank=False)
+    category = models.ForeignKey(
+        Category,
+        verbose_name="Category",
+        on_delete=models.PROTECT,
+        blank=True,
+        null=True,
+    )
+    value = models.DecimalField(max_digits=9, decimal_places=2, blank=False, null=False)
+    received_value = models.DecimalField(
+        max_digits=9, decimal_places=2, blank=True, null=True
+    )
+    liquid_value = models.DecimalField(
+        max_digits=9, decimal_places=2, blank=True, null=True
+    )
+    payment_method = models.ForeignKey(
+        PaymentMethod, on_delete=models.PROTECT, null=True
+    )
+    registry_classification = models.CharField(
+        max_length=30,
+        blank=True,
+        null=False,
+        default=RegistryClassification.VARIABLE,
+        choices=RegistryClassification.CHOICES,
+    )
+    number_of_payments = models.PositiveIntegerField(default=1, null=False, blank=False)
+    current_payment = models.PositiveIntegerField(default=1, null=False, blank=False)
+    frequency = models.IntegerField(
+        choices=Frequency, default=Frequency.NONE, null=True, blank=True
+    )
+    reference_record = models.ForeignKey(
+        "self", on_delete=models.PROTECT, null=True, blank=False, related_name="payments"
+    )
+    observation = models.TextField(blank=True, null=True)
+    cost_center = models.JSONField(default=dict)
+    account = models.ForeignKey(Account, on_delete=models.PROTECT, blank=True, null=True)
+    entry_type = models.CharField(max_length=1, choices=Type.CHOICES, blank=False)
+    person = models.JSONField(default=dict)
+    tag = models.TextField(blank=True, null=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    client_app = models.JSONField(default=dict, null=False, blank=False)

finance_sdk/models/payment.py

@@ -0,0 +1,29 @@
+from django.db import models
+
+class PaymentMethod(models.Model):
+    name = models.CharField("Nome", max_length=200, blank=False, null=False)
+    tax = models.DecimalField(
+        decimal_places=2, max_digits=9, blank=True, null=True, default=0
+    )
+    deactivate = models.BooleanField(default=False, blank=False, null=False)
+    created_at = models.DateTimeField(auto_now_add=True)
+    updated_at = models.DateTimeField(auto_now=True)
+    client_app = models.JSONField()
+
+
+    def __str__(self):
+        return self.nome
+
+    def save(self, *args, **kwargs):
+        if self.taxa == "":
+            self.taxa = 0
+
+        super(PaymentMethod, self).save(*args, **kwargs)
+
+
+class PaymentMethodTaxs(models.Model):
+    initial_payment = models.PositiveIntegerField()
+    final_payment = models.PositiveIntegerField()
+    tax = models.DecimalField(decimal_places=2, max_digits=5)
+    PaymentMethod = models.ForeignKey(PaymentMethod, on_delete=models.PROTECT)
+    client_app = models.JSONField()

finance_sdk/serializers/accounts.py

@@ -0,0 +1,45 @@
+from rest_framework import serializers
+from models.accounts import Account, AccountPermission
+
+
+class AccountSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Account
+        fields = ["id", "name", "bank"]
+
+    def validate_name(self, value):
+        if not (self.instance and value == self.instance.name):
+            if Account.objects.filter(
+                name=value, deactivate=False, client_app=self.initial_data.get('client_app')).exists():
+                raise serializers.ValidationError(
+                    "Already exists an account with this name."
+                )
+
+        return value
+    
+
+
+class AccountPermissionSerializer(serializers.ModelSerializer):
+    
+    class Meta:
+        model = AccountPermission
+        fields = ["id", "account", "employee"]
+        validators = []
+
+    def validate(self, attrs):
+        if (
+            AccountPermission.objects.filter(
+                employee__id=attrs["employee"],
+                account=attrs["account"],
+                deactivate=False,
+                account__deactivate=False,
+                account__bank__deactivate=False,
+            ).exists()
+        ):
+            raise serializers.ValidationError(
+                {"employee": "This employee already has permission"}
+            )
+
+        return attrs
+    
+

finance_sdk/serializers/bank.py

@@ -0,0 +1,20 @@
+from rest_framework import serializers
+from models.bank import Bank
+
+
+class BankSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Bank
+        fields = ["id", "name"]
+
+    def validate_name(self, value):
+        if not (self.instance and value == self.instance.name):
+            if Bank.objects.filter(
+                name=value, deactivate =False, client_app=self.initial_data.get('client_app')
+            ).exists():
+                raise serializers.ValidationError(
+                    "Already exists a bank with this name"
+                )
+
+        return value

finance_sdk/serializers/category.py

@@ -0,0 +1,31 @@
+from rest_framework import serializers
+from models.category import Category
+
+class CategorySerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Category
+        fields = [
+            "id",
+            "name",
+            "principal_category",
+            "is_entry",
+            "is_out",
+            "deactivate",
+        ]
+
+    def validate_name(self, value):
+        if not (self.instance and value == self.instance.name):
+            if Category.objects.filter(
+                name=value, deactivate=False, client_app=self.initial_data.get('client_app')).exists():
+                raise serializers.ValidationError(
+                    "Already exists a category with this name."
+                )
+
+            if Category.objects.filter(
+                name=value, deactivate=True, client_app=self.initial_data.get('client_app')).exists():
+                raise serializers.ValidationError(
+                    "Already exists a category with this name."
+                )
+
+        return value

finance_sdk/serializers/entry.py

@@ -0,0 +1,144 @@
+from django.db import transaction
+from datetime import date, timedelta
+
+from rest_framework import serializers
+from finance_sdk.models.entry import Entry
+from finance_sdk.models.accounts import AccountPermission
+
+from enums import Frequency, Type, RegistryClassification
+from services.entriesService import generate_entries
+
+class EntrySerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = Entry
+        fields = [
+            "id",
+            "description",
+            "value",
+            "received_value",
+            "liquid_value",
+            "category",
+            "account",
+            "cost_center",
+            "payment_date",
+            "due_date",
+            "payment_method",
+            "person",
+            "entry_type",
+            "registry_classification",
+            "tag",
+            "number_of_payments",
+            "current_payment",
+            "frequency", 
+            "reference_record",
+           
+        ]
+
+        read_only_fields = [
+            "current_payment",
+            "reference_record",
+            "frequency",
+            "liquid_value",
+        ]
+
+    @transaction.atomic
+    def create(self, validated_data):
+        return generate_entries(self.initial_data, validated_data)
+
+    def update(self, instance, validated_data):
+        validated_data["number_of_payments"] = instance.number_of_payments
+        validated_data["frequency"] = instance.frequency
+        validated_data["reference_record"] = instance.reference_record
+        value = validated_data.get("value")
+        entry_type = (
+            validated_data.get("entry_type")
+            if validated_data.get("entry_type") is not None
+            else instance.entry_type
+        )
+        if value is not None and entry_type == Entry.entry_type.ENTRY:
+            payment_method = (
+                validated_data.get("payment_method")
+                if validated_data.get("payment_method") is not None
+                else instance.payment_method
+            )
+            if payment_method is not None:
+                validated_data["liquid_value"] = value * (payment_method.tax / 100)
+
+        if self.context.get("recalcular") and instance.forma_pagamento is not None:
+            validated_data["valor_liquido"] = instance.valor * (
+                instance.forma_pagamento.taxa / 100
+            )
+
+        return super().update(instance, validated_data)
+
+    def validate_payment_date(self, value):
+        DATE_LIMIT = date(2000, 1, 1)
+
+        if DATE_LIMIT > value:
+            raise serializers.ValidationError(
+                "Date can't be lower then 2000-01-01"
+            )
+
+        return value
+
+    def validate_due_date(self, value):
+        DATE_LIMIT = date(2000, 1, 1)
+
+        if DATE_LIMIT > value:
+            raise serializers.ValidationError(
+                "Date can't be lower then 2000-01-01"
+            )
+        return value
+
+    def validate_value(self, value):
+        if not value > 0:
+            raise serializers.ValidationError("The value must be greater than 0")
+
+        return value
+
+    def validate_account(self, value):
+        if not AccountPermission.objects.filter(
+            account=value, employee_id=self.initial_data.get('employee')
+        ).exists():
+            raise serializers.ValidationError("Invalid Account")
+
+        return value
+
+    def validate_number_of_payments(self, value):
+        if not value > 0:
+            raise serializers.ValidationError(
+                "Number of payments must be greater then 0"
+            )
+
+        return value
+
+    
+    def validate(self, attrs):
+        frequency = attrs.get("frequency", Frequency.NONE)
+
+        if (frequency == Frequency.NONE) and (attrs.get("number_of_payments", 1) > 1):
+            raise serializers.ValidationError(
+                {
+                    "message": "An accounts payable/receivable entry without any recurrence cannot have more than one payment."
+                } 
+            )
+
+        if (attrs.get("number_of_payments", 1) == 1) and (
+            frequency != Frequency.NONE
+        ):
+            raise serializers.ValidationError(
+                {
+                    "message": "The number of payments must be greater than 1 in order to have a frequency."
+                }  )
+
+        value = attrs.get("value")
+        entry_type = attrs.get("entry_type")
+        if value and entry_type == Type.ENTRY:
+            paid_value = attrs.get("paid_value", 0)
+            if value < paid_value:
+                raise serializers.ValidationError(
+                    {"message": "The Paid value can't be greater than the value."}
+                )
+
+        return attrs

finance_sdk/serializers/payments.py

@@ -0,0 +1,73 @@
+from rest_framework import serializers
+from models.payment import PaymentMethod, PaymentMethodTaxs
+
+
+class PaymentMethodSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = PaymentMethod
+        fields = ["id", "name", "tax"]
+
+    def validate_name(self, value):
+        if not (self.instance and value == self.instance.name):
+            if PaymentMethod.objects.filter(
+                name=value, deactivate=False, client_app=self.initial_data.get('client_app')).exists():
+                raise serializers.ValidationError(
+                    "Already exists a payment method with this name."
+                )
+
+        return value
+
+    def validate_tax(self, value):
+        if  value is not None and value < 0:
+            raise serializers.ValidationError("the tax can't be negative")
+
+        return value
+
+
+class PaymentMethodTaxsSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = PaymentMethodTaxs
+        fields = ["id", "initial_payment", "final_payment", "tax"]
+
+    def validate(self, attrs):
+        if attrs["initial_payment"] > attrs["final_payment"]:
+            raise serializers.ValidationError(
+                {"menssage": " The initial payment can't be bigger then the final_payment"}
+            )
+
+        taxs = PaymentMethodTaxs.objects.filter(
+            payment_method_id=self.context.get("payment_method_id"),
+            client_app=self.initial_data.get('client_app'),
+        )
+
+        if self.instance:
+            taxs = taxs.exclude(id=self.instance.id)
+
+        for tax in taxs:
+            if attrs["initial_payment"] in range(
+                tax.initial_payment, tax.final_payment + 1
+            ):
+                raise serializers.ValidationError(
+                    {
+                        "initial_payment": "Already exists a tax for this payment in this payment method."
+                    }
+                )
+            elif attrs["final_payment"] in range(
+                tax.initial_payment, tax.final_payment + 1
+            ):
+                raise serializers.ValidationError(
+                    {
+                        "final_payment": "Already exists a tax for this payment in this payment method."
+                    }
+                )
+            elif (
+                tax.initial_payment >= attrs["initial_payment"]
+                and tax.final_payment <= attrs["final_payment"]
+            ):
+                raise serializers.ValidationError(
+                    {
+                        "menssage": "Already exists a tax for this payments in this payment method."
+                    }
+                )
+
+        return attrs

finance_sdk/services/entriesService.py

@@ -0,0 +1,77 @@
+from datetime import date, timedelta
+from finance_sdk.models.entry import Entry
+
+
+from enums import Frequency
+
+def generate_entries(validated_data, initial_data):
+    number_of_payments = validated_data.get("number_of_payments", 1)
+    payment_value = validated_data.get("value") / number_of_payments
+    frequency = validated_data.get("frequency")
+    validated_data["frequency"] = Frequency.get_frequency(frequency=frequency)
+    primary_payment = Entry.objects.create(**validated_data)
+    payment_method = primary_payment.payment_method
+    tax = payment_method.tax / 100 if payment_method else 0
+    liquid_value = (
+            payment_value - payment_value * tax
+            if validated_data.get("type") == Entry.entry_type.ENTRY
+            else None
+        )
+    primary_payment.value = payment_value
+    primary_payment.liquid_value = liquid_value
+    primary_payment.client_app = initial_data.get('client_app')
+    primary_payment.reference_record_id = primary_payment.id
+    primary_payment.save()
+
+    if number_of_payments > 1:
+            entry_payments = []
+            for payment in range(2, number_of_payments + 1):
+                entry_payments.append(
+                    Entry(
+                        description=validated_data.get("description"),
+                        value=payment_value,
+                        liquid_value=liquid_value,
+                        category=validated_data.get("category"),
+                        account=validated_data.get("account"),
+                        cost_center=validated_data.get("cost_center"),
+                        due_date=validated_data.get("due_date")
+                        + timedelta(days=frequency * (payment - 1)),
+                        payment_method=validated_data.get("payment_method"),
+                        person=validated_data.get("person"),
+                        entry_type=validated_data.get("entry_type"),
+                        registry_classification=validated_data.get(
+                            "registry_classification"
+                        ),
+                        number_of_payments=validated_data.get("number_of_payments"),
+                        current_payment=payment,
+                        frequency=primary_payment.frequency,
+                        reference_record_id=primary_payment.pk,
+                        client_app=initial_data.get('client_app'),
+                    )
+                )
+
+            Entry.objects.bulk_create(entry_payments)
+    else:
+        received_value = validated_data.get("received_value", 0)
+        total_value = validated_data.get("value", 0)
+
+            
+    if received_value < total_value and received_value > 0:
+                Entry.objects.create(
+                    description=validated_data.get("description"),
+                    value=total_value - received_value,
+                    category=validated_data.get("category"),
+                    account=validated_data.get("account"),
+                    cost_center=validated_data.get("cost_center"),
+                    due_date=validated_data.get("due_date"),
+                    person=validated_data.get("person"),
+                    entry_type=validated_data.get("entry_type"),
+                    registry_classification=validated_data.get("registry_classification"),
+                    number_of_payments=validated_data.get("numero_parcelas", 1),
+                    cliente_app_id=initial_data.get('client_app'),
+                )
+
+    return primary_payment
+    
+
+

finance_sdk/tests.py

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

finance_sdk/utils.py

@@ -0,0 +1,63 @@
+from django.forms import ValidationError
+
+
+
+def raise_error(message):
+    raise ValidationError(
+        {
+            "message": message,
+        })
+
+
+def validate_item_in_list(
+         item, list, message, message_if_empty="", required=False
+    ):
+        if required and not item:
+            raise_error(message_if_empty)
+
+        if item:
+            if isinstance(item, list):
+                itens = item
+
+                return (
+                    itens
+                    if all(item in list for item in itens)
+                    else raise_error(message)
+                )
+
+            return item if item in list else raise_error(message)
+
+        return False
+
+
+
+def validate_natural_number(
+         number, message, message_if_empty="", required=False
+    ):
+        if isinstance(number, list):
+            number = list(filter(lambda x: x.strip() != "", number))
+
+        elif isinstance(number, str) and number.strip() == "":
+            number = None
+
+        if required and not number:
+            raise_error(message_if_empty)
+
+        if number:
+            if isinstance(number, list):
+                numbers = number
+                to_int = lambda x: int(x)
+
+                return (
+                    list(map(to_int, numbers))
+                    if all(number.isnumeric() and number != "0" for number in numbers)
+                    else  raise_error(message)
+                )
+
+            return (
+                number
+                if number.isnumeric() and number != "0"
+                else raise_error(message)
+            )
+
+        return False

finance_sdk/views/account.py

@@ -0,0 +1,50 @@
+import operator
+from functools import reduce
+from rest_framework import viewsets
+from rest_framework.views import APIView
+
+from django.db.models.query_utils import Q
+
+from models.accounts import Account, AccountPermission
+from serializers.accounts import AccountSerializer, AccountPermissionSerializer
+
+
+
+class AccountViewSet(viewsets.ModelViewSet):
+
+    serializer_class = AccountSerializer
+    queryset = Account.objects.all()
+    
+    def get_queryset(self):
+        queryset = super().get_queryset()
+
+        query = Q(deactivate=False)
+
+        if self.action == "list":
+            LIST = "list"
+            INDICATORS = "indicators"
+
+            name = str(self.request.query_params.get("name", ""))
+
+            use = self.validate_item_in_list(
+                item=self.request.query_params.get("use", "list"),
+                list=[LIST, INDICATORS],
+                message="Invalid",
+                required=True,
+            )
+
+            if use == INDICATORS:
+                queryset = AccountPermission.get_conta(
+                    self.request.user.id, self.request.META["HTTP_CLIENTE_APP_ID"]
+                )
+
+            if name != "":
+                query &= reduce(
+                    operator.__and__,
+                    (
+                        Q(name__unaccent__icontains=word)
+                        for word in name.split(" ")
+                    ),
+                )
+
+        return queryset.filter(query).order_by("name")

finance_sdk/views/bank.py

@@ -0,0 +1,30 @@
+import operator
+from functools import reduce
+from rest_framework import viewsets
+from rest_framework.views import APIView
+
+from django.db.models.query_utils import Q
+
+from models.bank import Bank
+from serializers.bank import BankSerializer
+
+class BankViewSet(viewsets.ModelViewSet):
+
+    serializer_class = BankSerializer
+    queryset = Bank.objects.all()
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+
+        query = Q(deactivate=False)
+
+        if self.action == "list":
+            name = str(self.request.query_params.get("name", "")).split(" ")
+
+            if name != "":
+                query &= reduce(
+                    operator.__and__,
+                    (Q(name__unaccent__icontains=word) for word in name),
+                )
+
+        return queryset.filter(query).order_by("-name")

finance_sdk/views/category.py

@@ -0,0 +1,36 @@
+import operator
+from functools import reduce
+from rest_framework import viewsets
+from rest_framework.views import APIView
+
+from django.db.models.query_utils import Q
+
+from models.category import Category
+from serializers.category import CategorySerializer
+
+
+class CategoryViewSet(viewsets.ModelViewSet):
+    serializer_class = CategorySerializer
+    queryset = Category.objects.all()
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+
+        query = Q()
+
+        if self.action == "list":
+            query_params = self.request.query_params
+
+            name = str(query_params.get("name", "")).split(" ")
+
+            if name != "":
+                query &= reduce(
+                    operator.__and__,
+                    (Q(name__unaccent__icontains=word) for word in name),
+                )
+
+            deactivates = query_params.get("deactivate", "").lower() == "true"
+
+            query &= Q(deactivate=deactivates)
+
+        return queryset.filter(query).order_by("name")

finance_sdk/views/entry.py

@@ -0,0 +1,206 @@
+from argparse import Action
+import operator
+from functools import reduce
+from rest_framework.response import Response
+from rest_framework import viewsets
+from rest_framework.views import APIView
+
+from django.db.models.query_utils import Q
+from finance_sdk_wlc.finance_sdk.utils import validate_item_in_list, validate_natural_number
+
+from enums import Frequency, Type
+
+from models.entry import Entry
+from serializers.entry import EntrySerializer
+
+from models.accounts import Account, AccountPermission
+
+
+class EntryViewSet( viewsets.ModelViewSet):
+
+    serializer_class = EntrySerializer
+    queryset = Entry.objects.all()
+    
+
+    def get_queryset(self):
+        client_app_id = self.request.query_params.get("client_app")
+        employee_id = self.request.query_params.get("employee")
+
+        queryset = self.queryset
+
+        query = (
+            (
+                Q(
+                    account_id__in=AccountPermission.get_conta(
+                        self.request.user.id, client_app_id
+                    ),
+                    account__deactivate=False,
+                    account__bank__deactivate=False,
+                )
+                    | Q(account__isnull=True) )
+            & 
+
+             (
+               Q(payment_method__isnull=False, payment_method__desativada=False)
+                | Q(payment_method__isnull=True)
+            )
+            & (
+                Q(category__isnull=False, category__deactivate=False)
+                | Q(category__isnull=True)
+            )
+
+            (
+                Q(person_isnull=False) | Q(person_isnull=True)
+            )
+        )
+
+        person_id = self.request.query_params.getlist("person_ids", [])
+
+        if person_id:
+            query &= Q(person__id__in=person_id)
+
+        if client_app_id:
+            query &= Q(client_app__id=client_app_id)
+
+        cost_center_id = self.request.query_params.getlist("cost_center", [])
+        
+        if cost_center_id:
+            query &= Q(cost_center__id__in=cost_center_id)
+
+
+        if self.action == "list":
+            query_params = self.request.query_params
+
+            entry_type = self.validate_item_in_list(
+                item=query_params.get("tipo", False),
+                lista=dict(Entry.Type.TYPE).keys(),
+                message="Entry type invalid",
+                message_if_empty="Entry type required",
+                required=True,
+            )
+
+            initial_date, final_date = self.validar_periodo_datas(
+                initial_date=query_params.get("initial_date", False),
+                final_date=query_params.get("final_date", False),
+            )
+
+            query &= Q(
+                entry_type=entry_type, due_date__gte=initial_date, due_date__lte=final_date
+            )
+
+            cost_center = validate_natural_number(
+                numero=query_params.get("cost_center", False),
+                mensagem="Invalid Cost Center",
+            )
+
+            if cost_center:
+                query &= Q(cost_center_id=cost_center)
+
+            person = query_params.get("person", False)
+
+            if person:
+                person = person.split(" ")
+                query &= reduce(
+                    operator.__and__,
+                    (Q(person__name__unaccent__icontains=param) for param in person),
+                )
+
+            category = validate_natural_number(
+                number=query_params.get("category", False),
+                message="Inválid Category",
+            )
+
+            if category:
+                query &= Q(categoria_id=category)
+
+            account = validate_natural_number(
+                number=query_params.get("account", False), message="Invalid Account"
+            )
+
+            if account:
+                query &= Q(account_id=account)
+
+        return queryset.filter(query).order_by(
+            "due_date", "category", "description", "created_at", "id"
+        )
+
+    def list(self, request, *args, **kwargs):
+        if "values" not in request.query_params:
+            return super().list(request, *args, **kwargs)
+ 
+        serializer_data = EntrySerializer(
+            {"Entry": self.get_queryset()}, context={"request": request}
+        ).data
+
+        return Response(data=serializer_data["valores"])
+
+    def update(self, request, *args, **kwargs):
+        partial = kwargs.pop("partial", False)
+        instance = self.get_object()
+        recalculate_liquid_value = request.data.get("recalculate", False)
+        serializer = EntrySerializer(
+            instance,
+            data=request.data,
+            partial=partial,
+            context={"request": request, "recalculate": recalculate_liquid_value},
+        )
+        serializer.is_valid(raise_exception=True)
+        self.perform_update(serializer)
+
+        if getattr(instance, "_prefetched_objects_cache", None):
+            instance._prefetched_objects_cache = {}
+
+        return Response(serializer.data)
+
+    def destroy(self, request, *args, **kwargs):
+        instance = self.get_object()
+
+        if Entry.objects.filter(reference_record=instance).count() > 1:
+            return Response(
+                {"message": "Payment deletion requires confirmation."},
+                ),
+              
+
+        instance.reference_record = None
+        instance.save()
+
+        self.perform_destroy(instance)
+
+        return Response(status=status.HTTP_204_NO_CONTENT)
+
+    @Action(methods=["GET"], detail=True, url_path="payments")
+    def list_payments(self, request, pk=None):
+        entry = self.get_object()
+
+        if entry.reference_record:
+            payments = Entry.objects.filter(
+                reference_record=entry.reference_record
+            ).order_by("id")
+        else:
+            payments = Entry.objects.filter(id=entry.id)
+
+        
+        page = self.paginate_queryset(payments)
+        serializer = self.get_serializer(page, many=True)
+
+        return self.get_paginated_response(serializer.data)
+
+        
+
+    @Action(methods=["DELETE"], detail=True, url_path="confirm_payment")
+    def confirm_payment_deletion(self, request, pk=None):
+        entry = self.get_object()
+
+        payments = Entry.objects.filter(reference_record=entry).exclude(
+            pk=entry.pk
+        )
+
+        for payment in payments:
+            self.perform_destroy(payment)
+
+        entry.reference_record = None
+        entry.save()
+
+        self.perform_destroy(entry)
+
+        return Response()

finance_sdk/views/payment.py

@@ -0,0 +1,56 @@
+import operator
+from functools import reduce
+from rest_framework import viewsets
+from rest_framework.views import APIView
+from django.http.response import Http404, HttpResponse
+from rest_framework.response import Response
+
+from django.db.models.query_utils import Q
+
+from models.payment import PaymentMethod, PaymentMethodTaxs
+from serializers.payments import PaymentMethodSerializer, PaymentMethodTaxsSerializer
+
+
+class PaymentMethodViewSet(viewsets.ModelViewSet):
+
+    serializer_class = PaymentMethodSerializer
+    queryset = PaymentMethod.objects.all()
+
+    def get_queryset(self):
+        queryset = super().get_queryset()
+
+        query = Q(deactivate=False)
+
+        if self.action == "list":
+            name = str(self.request.query_params.get("name", "")).split(" ")
+
+            if name != "":
+                query &= reduce(
+                    operator.__and__,
+                    (Q(name__unaccent__icontains=word) for word in name),
+                )
+
+        return queryset.filter(query).order_by("name")
+
+
+class ListPaymentMethodTaxs(viewsets.ModelViewSet):
+
+    serializer_class = PaymentMethodTaxsSerializer
+    queryset = PaymentMethodTaxs.objects.all()
+    
+    def get_queryset(self):
+        queryset = super().get_queryset()
+
+        query = Q(deactivate=False)
+
+        if self.action == "list":
+            tax = str(self.request.query_params.get("tax", "")).split(" ")
+
+            if tax != "":
+                query &= reduce(
+                    operator.__and__,
+                    (Q(tax__icontains=word) for word in tax),
+                )
+
+        return queryset.filter(query).order_by("initial_date")
+    

finance_sdk-1.0.3.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: finance_sdk
+Version: 1.0.3
+Summary: SDK for Finance Module
+Home-page: https://github.com/wlc-solucoes/wlc-sdk-financeiro.git
+Author: WLC Soluções
+Author-email: analiciasouza.11@gmail.com
+Classifier: Environment :: Web Environment
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Requires-Dist: django
+Requires-Dist: djangorestframework
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+# SDK Financeiro - WLC Soluções
+
+

finance_sdk-1.0.3.dist-info/RECORD

@@ -0,0 +1,31 @@
+finance_sdk/__init__.py,sha256=Gzuvw8Ow_dRgrZIJptCgRtdYkXj-2sqilDbIlIxdHK8,78
+finance_sdk/admin.py,sha256=suMo4x8I3JBxAFBVIdE-5qnqZ6JAZV0FESABHOSc-vg,63
+finance_sdk/apps.py,sha256=UA4iSvwSqXkM9Dwlr3O8vO6AX8z3hwAQ9W5TnBGPMvE,153
+finance_sdk/enums.py,sha256=V-Cn2r4KGoqxW35iK-_T_ve5KSxg2fJromIhcW-G2Dw,1176
+finance_sdk/tests.py,sha256=mrbGGRNg5jwbTJtWWa7zSKdDyeB4vmgZCRc2nk6VY-g,60
+finance_sdk/utils.py,sha256=zgZPMmxXeN9dAYPYvL4a3LECTeR7WFfVz1T0RZF3m44,1594
+finance_sdk/migrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+finance_sdk/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+finance_sdk/models/accounts.py,sha256=E41hh6yjrRpwfPtIwqGUZpC-q6ZxxS0MdwPrEyjGidI,1417
+finance_sdk/models/bank.py,sha256=NHI1Dxd6VcxbKC2WeaLA5qG4BRlOY5oU7oqGzHArYyY,397
+finance_sdk/models/category.py,sha256=FwUBQ2aDedyytfX6GOFKynM4N_u45qcwCm4_oAoBfu0,669
+finance_sdk/models/entry.py,sha256=hDGeXDgyuJNhrgY3jUN4hPs5txhSxGqE-2NmzucKpKA,2153
+finance_sdk/models/payment.py,sha256=4-5cHpYvor3mzSORfJ1SIyv_yeaK5LJYLtQb_vi9EuA,995
+finance_sdk/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+finance_sdk/serializers/accounts.py,sha256=JpWDwOQ4Ii08iYHd8TTPZjyFkS8PguIRfnT6KGL3oZw,1325
+finance_sdk/serializers/bank.py,sha256=toIYBVwwoGv8BXbcTHI5DhVrsHtrRoIgGjcSQ14FJ7o,596
+finance_sdk/serializers/category.py,sha256=ahx5wpHqvtYdVtFUDgUK_CrPyGEWDm_guP_7lH4VlvE,1023
+finance_sdk/serializers/entry.py,sha256=lheWYdzhAa4WyZByGMxuvCKZMYP5y9vWZDwJEWngtq0,4665
+finance_sdk/serializers/payments.py,sha256=ODmxwTzsmjsZ7ZFqCkS5MFniLDJRumXdI7mAf7CCUg4,2643
+finance_sdk/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+finance_sdk/services/entriesService.py,sha256=esQ7F-wJ1SLRzoooIJKadX_gQvvlOpiTaD7oz3Wy2KY,3504
+finance_sdk/views/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+finance_sdk/views/account.py,sha256=ptpnONCxRtCGMS2hGfo9WOQTqzSSY2ybHcAsVZKSkfg,1461
+finance_sdk/views/bank.py,sha256=lrYVFSatTBEztW3HFbkMSYwMW5sJVwOqIyk_R6gxF64,824
+finance_sdk/views/category.py,sha256=GGVZaRsxGz3y4urbCizIcmvZXVedndrF9rbsiyI6bpk,1003
+finance_sdk/views/entry.py,sha256=pIuCiLiW0Kz_-9qDVn4XmeSAQlSoa0K4oxGUa9Jwer0,6420
+finance_sdk/views/payment.py,sha256=lECY1E0tGguDZqjJ6xrGvCY-osGy3FR9RAgzz6QdupM,1646
+finance_sdk-1.0.3.dist-info/METADATA,sha256=ae5-wb_vHXpL37nW8wY_ZVxNdbh6UG4_rqNTuLT8aq8,590
+finance_sdk-1.0.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+finance_sdk-1.0.3.dist-info/top_level.txt,sha256=VghHbEzVbFaLJhFhyllLz1gaRt6DXhz_oBMN204-cNY,12
+finance_sdk-1.0.3.dist-info/RECORD,,

finance_sdk-1.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

finance_sdk-1.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+finance_sdk