alegra-e-provider 0.0.1__tar.gz

alegra_e_provider-0.0.1/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.2
+Name: alegra-e-provider
+Version: 0.0.1
+Summary: Alegra E-Provider, Python Wrapper for Alegra Electronic Provider API
+Author: Luis Martinez
+Requires-Python: >=3.6
+Requires-Dist: pydantic[email]==2.8.2
+Requires-Dist: requests==2.32.3
+Requires-Dist: httpx==0.27.2
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

alegra_e_provider-0.0.1/README.md

@@ -0,0 +1,171 @@
+# Alegra API Client
+
+This project provides an API client for the Alegra platform using the `pydantic` and `requests` libraries. The modular structure allows for flexible and extensible resource management.
+
+## Installation
+
+1. Clone the repository.
+2. Install the required dependencies:
+   ```sh
+   pip install -r requirements.txt
+   ```
+
+## Configuration
+
+Create a configuration object to handle API key and environment settings.
+
+```python
+from config import ApiConfig
+
+config = ApiConfig(api_key='your_api_key', environment='sandbox')
+```
+
+## Usage
+
+Initialize the API client with the configuration:
+
+```python
+from client import ApiClient
+
+client = ApiClient(config)
+```
+
+### Company Operations
+
+#### Create a Company
+
+```python
+from models.company import Company, NotificationByEmail
+
+company_data = Company(
+    useAlegraCertificate=True,
+    notificationByEmail=NotificationByEmail(enabled=True)
+)
+new_company = client.companies.create(company_data)
+print(new_company.id, new_company.name)
+```
+
+#### Get a Company
+
+```python
+company = client.companies.get("company_id")
+print(company.id, company.name)
+```
+
+#### Update a Company
+
+```python
+updated_data = Company(name="Updated Company Name")
+updated_company = client.companies.update("company_id", updated_data)
+print(updated_company.name)
+```
+
+#### List Companies
+
+```python
+companies = client.companies.list()
+for company in companies:
+    print(company.id, company.name)
+```
+
+### Payroll Operations
+
+#### Create a Payroll
+
+```python
+from models.payroll import Payroll
+
+payroll_data = Payroll(
+    prefix="NE",
+    number=1,
+    governmentData={"key": "value"}
+)
+new_payroll = client.payrolls.create(payroll_data)
+print(new_payroll.id, new_payroll.prefix)
+```
+
+#### Get a Payroll
+
+```python
+payroll = client.payrolls.get("payroll_id")
+print(payroll.id, payroll.prefix)
+```
+
+#### Update a Payroll
+
+```python
+updated_data = Payroll(prefix="NE", number=2)
+updated_payroll = client.payrolls.update("payroll_id", updated_data)
+print(updated_payroll.number)
+```
+
+#### List Payrolls
+
+```python
+payrolls = client.payrolls.list()
+for payroll in payrolls:
+    print(payroll.id, payroll.prefix)
+```
+
+#### Replace a Payroll
+
+```python
+replacement_data = Payroll(prefix="NE", number=2, governmentData={"key": "new_value"})
+replaced_payroll = client.payrolls.perform_subaction("payroll_id", "replace", replacement_data)
+print(replaced_payroll.id, replaced_payroll.number)
+```
+
+#### Cancel a Payroll
+
+```python
+cancel_response = client.payrolls.perform_subaction("payroll_id", "cancel")
+print(cancel_response)
+```
+
+### DIAN Operations
+
+#### List DIAN Resources
+
+```python
+dian_resources = client.dian.list()
+for resource in dian_resources:
+    print(resource.id, resource.name)
+```
+
+### Test Set Operations
+
+#### Create a Test Set
+
+```python
+from models.test_set import TestSet
+
+test_set_data = TestSet(
+    type="test",
+    governmentId="gov123",
+    idCompany="company_id"
+)
+new_test_set = client.test_sets.create(test_set_data)
+print(new_test_set.id)
+```
+
+#### Get a Test Set
+
+```python
+test_set = client.test_sets.get("test_set_id")
+print(test_set.id, test_set.type)
+```
+
+## Error Handling
+
+The client raises exceptions for HTTP errors, which can be caught and handled appropriately.
+
+```python
+try:
+    new_company = client.companies.create(company_data)
+except requests.exceptions.RequestException as e:
+    print(f"An error occurred: {e}")
+```
+
+## License
+
+This project is licensed under the MIT License.

alegra_e_provider-0.0.1/alegra/client.py

@@ -0,0 +1,141 @@
+import requests
+import httpx
+
+from alegra.config import ApiConfig
+from alegra.models.company import Company
+from alegra.models.dian import DianResource
+from alegra.models.invoice import Invoice, InvoiceResponse, FileResponse
+from alegra.models.payroll import Payroll
+from alegra.models.test_set import TestSet
+from alegra.resources.factory import ResourceFactory
+
+
+class ApiClient:
+    def __init__(self, config: ApiConfig, async_mode=False):
+        self.config = config
+        self.base_url = self.config.get_base_url()
+        self.async_mode = async_mode
+        self._initialize_resources()
+
+    async def _async_request(self, method, endpoint, **kwargs):
+        url = f"{self.base_url}/{endpoint}"
+        async with httpx.AsyncClient(
+            headers={"Authorization": f"Bearer {self.config.api_key}"}, timeout=30.0
+        ) as client:
+            response = await client.request(method, url, **kwargs)
+            return response.json()
+
+    def _sync_request(self, method, endpoint, **kwargs):
+        url = f"{self.base_url}/{endpoint}"
+        with requests.Session() as session:
+            session.headers.update({"Authorization": f"Bearer {self.config.api_key}"})
+            response = session.request(method, url, **kwargs)
+            return response.json()
+
+    def _request(self, method, endpoint, **kwargs):
+        if self.async_mode:
+            return self._async_request(method, endpoint, **kwargs)
+        else:
+            return self._sync_request(method, endpoint, **kwargs)
+
+    def _initialize_resources(self):
+        self.company = ResourceFactory(
+            self,
+            "company",
+            self._request,
+            {
+                "get": {
+                    "model": Company,
+                    "response_model": Company,
+                    "response_key": "company",
+                },
+                "update": {
+                    "model": Company,
+                    "response_model": Company,
+                    "response_key": "company",
+                },
+            },
+        )
+        self.companies = ResourceFactory(
+            self,
+            "companies",
+            self._request,
+            {
+                "create": {
+                    "model": Company,
+                    "response_model": Company,
+                    "response_key": "company",
+                },
+                "get": {
+                    "model": Company,
+                    "response_model": Company,
+                    "response_key": "company",
+                },
+                "update": {
+                    "model": Company,
+                    "response_model": Company,
+                    "response_key": "company",
+                },
+                "list": {
+                    "model": Company,
+                    "response_model": Company,
+                    "response_key": "companies",
+                },
+            },
+        )
+        self.payrolls = ResourceFactory(
+            self,
+            "payrolls",
+            self._request,
+            {
+                "create": {"model": Payroll, "response_key": "payroll"},
+                "get": {"model": Payroll, "response_key": "payroll"},
+                "update": {"model": Payroll, "response_key": "payroll"},
+                "list": {"model": Payroll, "response_key": "payrolls"},
+                "perform__replace": {"model": Payroll, "response_key": "payroll"},
+                "perform__cancel": {"model": Payroll, "response_key": "payroll"},
+            },
+        )
+        self.dian = ResourceFactory(
+            self,
+            "dian",
+            self._request,
+            {"list": {"model": DianResource, "response_key": "dian"}},
+        )
+        self.test_sets = ResourceFactory(
+            self,
+            "test-sets",
+            self._request,
+            {
+                "create": {"model": TestSet, "response_key": "test_set"},
+                "get": {"model": TestSet, "response_key": "test_set"},
+            },
+        )
+        self.invoices = ResourceFactory(
+            self,
+            "invoices",
+            self._request,
+            {
+                "create": {
+                    "model": Invoice,
+                    "response_model": InvoiceResponse,
+                    "response_key": "invoice",
+                },
+                "get": {
+                    "model": Invoice,
+                    "response_model": InvoiceResponse,
+                    "response_key": "invoice",
+                },
+                "perform__file_xml": {
+                    "model": FileResponse,
+                    "endpoint_suffix": "files/XML",
+                    "response_model": FileResponse,
+                    "response_key": "file",
+                },
+                "list": {
+                    "model": InvoiceResponse,
+                    "response_model": InvoiceResponse,
+                    "response_key": "invoices",
+                },
+            },
+        )

alegra_e_provider-0.0.1/alegra/config.py

@@ -0,0 +1,14 @@
+from pydantic import BaseModel
+
+
+class ApiConfig(BaseModel):
+    api_key: str
+    environment: str
+
+    def get_base_url(self):
+        if self.environment == 'sandbox':
+            return 'https://sandbox-api.alegra.com/e-provider/col/v1'
+        elif self.environment == 'production':
+            return 'https://api.alegra.com/e-provider/col/v1'
+        else:
+            raise ValueError("Invalid environment. Choose 'sandbox' or 'production'.")

alegra_e_provider-0.0.1/alegra/models/address.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class Address(BaseModel):
+    address: str = ""
+    city: str = ""
+    department: str = ""
+    country: str = ""

alegra_e_provider-0.0.1/alegra/models/company.py

@@ -0,0 +1,105 @@
+import re
+from typing import Dict, Optional
+
+from pydantic import BaseModel, EmailStr, field_validator, model_validator
+
+from .address import Address
+
+IDENTIFICATION_TYPES = [
+    "11",
+    "12",
+    "13",
+    "21",
+    "22",
+    "31",
+    "41",
+    "42",
+    "47",
+    "48",
+    "50",
+    "91",
+]
+
+
+class Webhook(BaseModel):
+    url: str = ""
+    headers: Dict[str, str] = {}
+    status: str = ""
+
+
+class Webhooks(BaseModel):
+    general: Dict[str, Webhook] = {}
+    payrolls: Dict[str, Webhook] = {}
+
+
+class Certificate(BaseModel):
+    name: str = ""
+    extension: str = ""
+    content: str = ""
+    password: str = ""
+    issuerName: str = ""
+    startDate: str = ""
+    endDate: str = ""
+    serialNumber: str = ""
+
+
+class GovernmentStatus(BaseModel):
+    payrolls: str = ""
+
+
+class NotificationByEmail(BaseModel):
+    enabled: bool = False
+
+
+class Company(BaseModel):
+    id: Optional[str] = None
+    name: str
+    tradeName: Optional[str] = None
+    identification: str
+    dv: str
+    useAlegraCertificate: bool
+    organizationType: int
+    identificationType: str
+    regimeCode: str = ""
+    email: EmailStr
+    phone: Optional[str] = ""
+    address: Address
+    governmentStatus: Optional[GovernmentStatus] = None
+    certificate: Optional[Certificate] = None
+    webhooks: Optional[Webhooks] = None
+    notificationByEmail: Optional[NotificationByEmail] = None
+
+    @field_validator("dv")
+    def validate_dv(cls, v):
+        if not re.match(r"^([0-9]{1})$", v):
+            raise ValueError("dv must be a single digit")
+        return v
+
+    @field_validator("identificationType")
+    def validate_identificationType(cls, v):
+        if len(v) > 2:
+            raise ValueError("identificationType must have a maximum length of 2")
+        if v not in IDENTIFICATION_TYPES:
+            raise ValueError(
+                f"identificationType must be one of the allowed values: {', '.join(IDENTIFICATION_TYPES)}"
+            )
+        return v
+
+    @field_validator("organizationType")
+    def validate_organizationType(cls, v):
+        if v not in [1, 2]:
+            raise ValueError("organizationType must be 1 or 2")
+        return v
+
+    @model_validator(mode="before")
+    def check_certificate(cls, values):
+        use_alegra_certificate = values.get("useAlegraCertificate")
+        if use_alegra_certificate:
+            return values
+
+        certificate = values.get("certificate")
+        if not use_alegra_certificate and not certificate:
+            raise ValueError(
+                "certificate is required when useAlegraCertificate is False"
+            )
+        return values

alegra_e_provider-0.0.1/alegra/models/customer.py

@@ -0,0 +1,17 @@
+from typing import Optional
+
+from pydantic import BaseModel, EmailStr
+
+from alegra.models.address import Address
+from alegra.models.phone_number import PhoneNumber
+
+
+class Customer(BaseModel):
+    name: str
+    organizationType: int
+    identificationType: str
+    identificationNumber: Optional[str]
+    dv: Optional[str]
+    email: Optional[EmailStr] = ""
+    address: Optional[Address] = None
+    phone: str = ""

alegra_e_provider-0.0.1/alegra/models/dian.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel
+
+
+class DianResource(BaseModel):
+    id: str
+    name: str

alegra_e_provider-0.0.1/alegra/models/invoice.py

@@ -0,0 +1,108 @@
+from datetime import datetime
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+from alegra.models.customer import Customer
+
+
+class Resolution(BaseModel):
+    resolutionNumber: str
+    prefix: str
+    minNumber: int
+    maxNumber: int
+    startDate: str
+    endDate: str
+    technicalKey: str
+
+
+class Taxes(BaseModel):
+    taxCode: str
+    taxAmount: float
+    taxPercentage: str
+    taxableAmount: float
+
+
+class Item(BaseModel):
+    code: str
+    description: str
+    price: float
+    quantity: int
+    unitCode: str
+    note: Optional[str] = ""
+    subtotal: float
+    taxAmount: float
+    total: float
+    discount: float
+    discountAmount: float
+    taxes: List[Taxes] = []
+
+
+class Payment(BaseModel):
+    paymentForm: str
+    paymentMethod: str
+    paymentDueDate: str
+
+
+class DiscountOrCharge(BaseModel):
+    isCharge: bool
+    reason: str
+    percentageAmount: float
+    amount: float
+    baseAmount: float
+
+
+class TotalAmounts(BaseModel):
+    grossTotal: float
+    taxableTotal: float
+    taxTotal: float
+    discountTotal: float
+    chargeTotal: float
+    advanceTotal: float
+    payableTotal: float
+    currencyCode: str
+
+
+class CompanyID(BaseModel):
+    id: str
+
+
+class Invoice(BaseModel):
+    documentType: str
+    resolution: Resolution
+    company: CompanyID
+    customer: Customer
+    number: int
+    note: Optional[str]
+    items: List[Item]
+    payments: List[Payment]
+    discountsAndCharges: List[DiscountOrCharge] = []
+    totalAmounts: TotalAmounts
+
+
+class GovernmentResponse(BaseModel):
+    code: str
+    message: str
+    errorMessages: List[str]
+
+
+class InvoiceResponse(BaseModel):
+    id: str
+    companyIdentification: str
+    customerIdentification: str
+    type: str
+    cufe: str
+    date: datetime
+    prefix: str
+    number: int
+    fullNumber: str
+    status: str
+    legalStatus: str
+    governmentResponse: GovernmentResponse
+    xmlFileName: str
+    zipFileName: str
+    qrCodeContent: str
+
+
+class FileResponse(BaseModel):
+    content: str

alegra_e_provider-0.0.1/alegra/models/payroll.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class Payroll(BaseModel):
+    id: str = None
+    prefix: str
+    number: int
+    governmentData: dict

alegra_e_provider-0.0.1/alegra/models/phone_number.py

@@ -0,0 +1,12 @@
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class PhoneNumber(BaseModel):
+    country_code: int
+    national_number: int
+    extension: Optional[str] = None
+    italian_leading_zero: Optional[bool] = None
+    number_of_leading_zeros: Optional[int] = None
+    preferred_domestic_carrier_code: Optional[int] = None

alegra_e_provider-0.0.1/alegra/models/test_set.py

@@ -0,0 +1,8 @@
+from pydantic import BaseModel
+
+
+class TestSet(BaseModel):
+    id: str
+    type: str
+    governmentId: str
+    idCompany: str

alegra_e_provider-0.0.1/alegra/resources/base.py

@@ -0,0 +1,133 @@
+from typing import Callable, Dict
+
+from pydantic import BaseModel
+
+
+class ApiResource:
+    def __init__(
+        self,
+        client,
+        endpoint: str,
+        request_method: Callable,
+        actions_config: Dict[str, Dict[str, str]],
+    ):
+        self.client = client
+        self.endpoint = endpoint
+        self.request_method = request_method
+        self.actions_config = actions_config
+
+    def _is_action_allowed(self, action: str):
+        return action in self.actions_config
+
+    def _parse_response(self, response, action: str):
+        response_key = self.actions_config[action].get("response_key")
+        if response_key:
+            if not response_key in response:
+                if response.get("message"):
+                    raise ValueError(response.get("message"))
+                if response.get("errors"):
+                    raise ValueError(response.get("errors"))
+                raise ValueError(f"Response key '{response_key}' not found in response")
+            response_data = response.get(response_key, response)
+        else:
+            response_data = response
+        model = self.actions_config[action]["response_model"]
+        return model.model_validate(response_data)
+
+    def _prepare_data(self, data: BaseModel):
+        data = data.model_dump()
+        if "customer" in data:
+            customer_data = data["customer"]
+            if customer_data["dv"] is None:
+                del customer_data["dv"]
+        return {k: v for k, v in data.items() if v is not None}
+
+    def get(self, resource_id: str):
+        action = "get"
+        if not self._is_action_allowed(action):
+            raise NotImplementedError(
+                f"The action 'get' is not allowed for {self.endpoint}"
+            )
+        endpoint = f"{self.endpoint}/{resource_id}"
+        response = self.request_method("GET", endpoint)
+        return self._parse_response(response, action)
+
+    def create(self, data: BaseModel):
+        if self.client.async_mode:
+            return self.create_async(data)
+        else:
+            action = "create"
+            if not self._is_action_allowed(action):
+                raise NotImplementedError(
+                    f"The action 'create' is not allowed for {self.endpoint}"
+                )
+            response = self.request_method(
+                "POST", self.endpoint, json=self._prepare_data(data)
+            )
+            return self._parse_response(response, action)
+
+    async def create_async(self, data: BaseModel):
+        action = "create"
+        if not self._is_action_allowed(action):
+            raise NotImplementedError(
+                f"The action 'create' is not allowed for {self.endpoint}"
+            )
+        response = await self.request_method(
+            "POST", self.endpoint, json=self._prepare_data(data)
+        )
+        return self._parse_response(response, action)
+
+    def update(self, resource_id: str, data: BaseModel):
+        action = "update"
+        if not self._is_action_allowed(action):
+            raise NotImplementedError(
+                f"The action 'update' is not allowed for {self.endpoint}"
+            )
+        endpoint = f"{self.endpoint}/{resource_id}"
+        response = self.request_method("PATCH", endpoint, json=self._prepare_data(data))
+        return self._parse_response(response, action)
+
+    def delete(self, resource_id: str):
+        action = "delete"
+        if not self._is_action_allowed(action):
+            raise NotImplementedError(
+                f"The action 'delete' is not allowed for {self.endpoint}"
+            )
+        endpoint = f"{self.endpoint}/{resource_id}"
+        response = self.request_method("DELETE", endpoint)
+        return response.status_code == 204
+
+    def list(self, params=None):
+        action = "list"
+        if not self._is_action_allowed(action):
+            raise NotImplementedError(
+                f"The action 'list' is not allowed for {self.endpoint}"
+            )
+        response = self.request_method("GET", self.endpoint, params=params)
+        return [
+            self.actions_config[action]["model"].model_validate(item)
+            for item in response.get(
+                self.actions_config[action].get("response_key", [])
+            )
+        ]
+
+    def perform_subaction(
+        self, resource_id: str, subaction: str, data: BaseModel = None
+    ):
+        action = f"perform__{subaction}"
+        if not self._is_action_allowed(action):
+            raise NotImplementedError(
+                f"The subaction '{subaction}' is not allowed for {self.endpoint}"
+            )
+        endpoint_suffix = self.actions_config[action].get("endpoint_suffix", subaction)
+        endpoint = f"{self.endpoint}/{resource_id}/{endpoint_suffix}"
+        response = self.request_method(
+            self._request_method_for_subaction(subaction),
+            endpoint,
+            json=self._prepare_data(data) if data else {},
+        )
+        return self._parse_response(response, action)
+
+    @staticmethod
+    def _request_method_for_subaction(subaction: str):
+        return "POST" if subaction in ["replace", "cancel"] else "GET"

alegra_e_provider-0.0.1/alegra/resources/factory.py

@@ -0,0 +1,36 @@
+from typing import Callable, Dict
+
+from pydantic import BaseModel
+
+from .base import ApiResource
+
+
+class ResourceFactory:
+    def __init__(
+        self,
+        client,
+        endpoint: str,
+        request_method: Callable,
+        actions_config: Dict[str, Dict[str, str]],
+    ):
+        self.resource = ApiResource(client, endpoint, request_method, actions_config)
+
+    def get(self, resource_id):
+        return self.resource.get(resource_id)
+
+    def create(self, data):
+        return self.resource.create(data)
+
+    def update(self, resource_id, data):
+        return self.resource.update(resource_id, data)
+
+    def delete(self, resource_id):
+        return self.resource.delete(resource_id)
+
+    def list(self, params=None):
+        return self.resource.list(params)
+
+    def perform_subaction(
+        self, resource_id: str, subaction: str, data: BaseModel = None
+    ):
+        return self.resource.perform_subaction(resource_id, subaction, data)

alegra_e_provider-0.0.1/alegra_e_provider.egg-info/PKG-INFO

@@ -0,0 +1,13 @@
+Metadata-Version: 2.2
+Name: alegra-e-provider
+Version: 0.0.1
+Summary: Alegra E-Provider, Python Wrapper for Alegra Electronic Provider API
+Author: Luis Martinez
+Requires-Python: >=3.6
+Requires-Dist: pydantic[email]==2.8.2
+Requires-Dist: requests==2.32.3
+Requires-Dist: httpx==0.27.2
+Dynamic: author
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

alegra_e_provider-0.0.1/alegra_e_provider.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+README.md
+setup.py
+alegra/__init__.py
+alegra/client.py
+alegra/config.py
+alegra/models/__init__.py
+alegra/models/address.py
+alegra/models/company.py
+alegra/models/customer.py
+alegra/models/dian.py
+alegra/models/invoice.py
+alegra/models/payroll.py
+alegra/models/phone_number.py
+alegra/models/test_set.py
+alegra/resources/__init__.py
+alegra/resources/base.py
+alegra/resources/factory.py
+alegra_e_provider.egg-info/PKG-INFO
+alegra_e_provider.egg-info/SOURCES.txt
+alegra_e_provider.egg-info/dependency_links.txt
+alegra_e_provider.egg-info/requires.txt
+alegra_e_provider.egg-info/top_level.txt
+tests/test_company.py
+tests/test_invoice.py

alegra_e_provider-0.0.1/alegra_e_provider.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

alegra_e_provider-0.0.1/alegra_e_provider.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pydantic[email]==2.8.2
+requests==2.32.3
+httpx==0.27.2

alegra_e_provider-0.0.1/alegra_e_provider.egg-info/top_level.txt

@@ -0,0 +1 @@
+alegra

alegra_e_provider-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

alegra_e_provider-0.0.1/setup.py

@@ -0,0 +1,16 @@
+from setuptools import find_packages, setup
+
+setup(
+    name="alegra-e-provider",
+    packages=find_packages(include=["alegra", "alegra.*"]),
+    version="0.0.1",
+    description="Alegra E-Provider, Python Wrapper for Alegra Electronic Provider API",
+    author="Luis Martinez",
+    install_requires=[
+        "pydantic[email]==2.8.2",
+        "requests==2.32.3",
+        "httpx==0.27.2",
+    ],
+    test_suite="tests",
+    python_requires=">=3.6",
+)

alegra_e_provider-0.0.1/tests/test_company.py

@@ -0,0 +1,57 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from alegra.client import ApiClient
+from alegra.config import ApiConfig
+from alegra.models.company import (
+    Address,
+    Certificate,
+    Company,
+    GovernmentStatus,
+    NotificationByEmail,
+    Webhook,
+    Webhooks,
+)
+
+
+class TestCompanyResource(unittest.TestCase):
+    def setUp(self):
+        self.config = ApiConfig(
+            api_key="ce5PgRbegtMgcwt9pPnPYNpCNuy0Nxmm5ohKZHSU", environment="sandbox"
+        )
+        self.client = ApiClient(self.config)
+
+    def test_create_company(self):
+        company_data = Company(
+            name="Soluciones Alegra S.A.S",
+            identification="111111111",
+            dv="2",
+            useAlegraCertificate=True,
+            governmentStatus=GovernmentStatus(payrolls="AUTHORIZED"),
+            organizationType=1,
+            identificationType="31",
+            regimeCode="R-99-PN",
+            email="email@email.com",
+            phone="1234567890",
+            address=Address(
+                address="Cra. 13 #12-12 Edificio A & A",
+                city="11001",
+                department="11",
+                country="CO",
+            ),
+        )
+
+        company = self.client.companies.create(company_data)
+
+        self.assertEqual(company.name, "Soluciones Alegra S.A.S")
+        self.assertEqual(company.identification, "111111111")
+        self.assertEqual(company.dv, "2")
+        self.assertTrue(company.useAlegraCertificate)
+        self.assertEqual(company.organizationType, 1)
+        self.assertEqual(company.identificationType, "31")
+        self.assertEqual(company.regimeCode, "R-99-PN")
+        self.assertEqual(company.email, "email@email.com")
+        self.assertEqual(company.address.address, "Cra. 13 #12-12 Edificio A & A")
+        self.assertEqual(company.address.city, "11001")
+        self.assertEqual(company.address.department, "11")
+        self.assertEqual(company.address.country, "CO")

alegra_e_provider-0.0.1/tests/test_invoice.py

@@ -0,0 +1,95 @@
+import unittest
+
+from alegra.client import ApiClient
+from alegra.config import ApiConfig
+from alegra.models.company import Address, Company, GovernmentStatus
+from alegra.models.invoice import Invoice
+
+
+class TestCompanyResource(unittest.TestCase):
+    def setUp(self):
+        self.config = ApiConfig(
+            api_key="ce5PgRbegtMgcwt9pPnPYNpCNuy0Nxmm5ohKZHSU", environment="sandbox"
+        )
+        self.client = ApiClient(self.config)
+
+    def test_create_invoice(self):
+
+        invoice_data = Invoice(
+            **{
+                "documentType": "01",
+                "resolution": {
+                    "resolutionNumber": "18760000001",
+                    "prefix": "SETP",
+                    "minNumber": 990000000,
+                    "maxNumber": 995000000,
+                    "startDate": "2019-01-19",
+                    "endDate": "2030-01-19",
+                    "technicalKey": "fc8eac422eba16e22ffd8c6f94b3f40a6e38162c",
+                },
+                "company": {
+                    "id": "01HTJ3D9NZA79Z6BRNHB19C6Z0",
+                },
+                "customer": {
+                    "address": {
+                        "address": "Cra. 13 #12-12 Edificio A & A",
+                        "city": "11001",
+                        "department": "11",
+                        "country": "CO",
+                    },
+                    "name": "Customer Name",
+                    "organizationType": 2,
+                    "identificationType": "13",
+                    "identificationNumber": "222222222222",
+                    "dv": "2",
+                    "email": "email@email.com",
+                    "phone": "3223334455",
+                },
+                "totalAmounts": {
+                    "grossTotal": 10000,
+                    "taxableTotal": 10000,
+                    "taxTotal": 1900,
+                    "discountTotal": 0,
+                    "chargeTotal": 0,
+                    "advanceTotal": 0,
+                    "payableTotal": 11900,
+                    "currencyCode": "COP",
+                },
+                "number": 990015000,
+                "note": "Nota relativa al documento",
+                "items": [
+                    {
+                        "code": "BM3",
+                        "standardCode": {"identificationId": "11001", "id": "001"},
+                        "description": "Botella de M3",
+                        "price": 10000,
+                        "discount": 0,
+                        "discountAmount": 0,
+                        "quantity": 1,
+                        "unitCode": "94",
+                        "subtotal": 10000,
+                        "taxAmount": 1900,
+                        "total": 11900,
+                        "taxes": [
+                            {
+                                "taxCode": "01",
+                                "taxAmount": 1900,
+                                "taxPercentage": "19.00",
+                                "taxableAmount": 10000,
+                                "taxBaseUnitMeasure": 1,
+                                "taxPerUnitAmount": 1,
+                            }
+                        ],
+                    }
+                ],
+                "payments": [
+                    {
+                        "paymentForm": "1",
+                        "paymentMethod": "10",
+                        "paymentDueDate": "2021-08-30",
+                    }
+                ],
+            }
+        )
+        invoice = self.client.invoices.create(invoice_data)
+        self.assertIsNotNone(invoice.id)