Merge branch 'develop_1' into 'main'

feat(repository): Integration of supporting packages

See merge request onix-systems/python-internal-mono!4

Author: avkozhevin

README.md

@@ -1,24 +1,65 @@
 # monobank-api-client
-This module is designed for quick interaction with the monobank API
+This module provides quick integration of the Monobank API for developing applications based on synchronous and asynchronous frameworks.
 
 ## Name
 monobank_api_client
 
 ## Installation
 This framework is published at the PyPI, install it with pip:
 
-    pip install monobank-api-client
+  1.This package makes it possible to use module methods in synchronous frameworks:
+
+    pip install monobank-api-client[http]
+
+  2.This package makes it possible to use module methods in asynchronous frameworks:
+
+    pip install monobank-api-client[aio]
+
+  3.This package makes it possible to use ready-made views with a synchronous script based on the Django Rest framework:
+
+    pip install monobank-api-client[drf]
+
+  To get started, add the following packages to INSTALLED_APPS:
+
+    INSTALLED_APPS = [
+        ...
+        'rest_framework',
+        'drf_mono',
+    ]
+
+  Include drf_mono urls to your urls.py:
+
+      urlpatterns = [
+          ...
+          path('mono/', include('drf_mono.urls', namespace='drf_mono')),
+      ]
+  
+  4.This package makes it possible to use ready-made routers with an asynchronous script based on the FastAPI framework:
+
+    pip install monobank-api-client[fastapi]
+
+  5.To install all packages at once:
+
+    pip install monobank-api-client[all]
 
 ## Usage
 
 1. Request your token at https://api.monobank.ua/
-2. Use that token to initialize client:
+2. For a synchronous request use that token to initialize client:
+
+    from sync_mono.manager import SyncMonoManager
+
+    token = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
+
+    mng = SyncMonoManager(token)
+
+3. For an asynchronous request, use this token to initialize the client:
 
-    from monobank_api_client.managers import MonoManager
+    from async_mono.manager import AsyncMonoManager
 
     token = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 
-    mng = MonoManager(token)
+    mng = AsyncMonoManager(token)
 
 ### Methods
 

monobank_api_client/async_mono/__init__.py

@@ -0,0 +1,108 @@
+import aiohttp
+from typing import Dict
+from mono_config.manager import BaseMonoManager
+
+
+class AsyncMonoManager(BaseMonoManager):
+    @classmethod
+    async def session(cls) -> aiohttp.client.ClientSession:
+        return aiohttp.ClientSession()
+
+    async def async_request(
+        self,
+        method: str,
+        uri: str,
+        headers=None,
+        data=None,
+    ) -> Dict:
+        session = await self.session()
+        if method == "GET":
+            response = await session.get(uri, headers=headers)
+        if method == "POST":
+            response = await session.post(uri, headers=headers, data=data)
+        try:
+            code = response.status
+            response.raise_for_status()
+            detail = await response.json()
+            payload = self.mono_response(code, detail)
+            return payload
+        except aiohttp.ClientResponseError as exc:
+            error_response = self.mono_response(code, str(exc.message))
+            return error_response
+        except Exception as exc:
+            exception = {"detail": str(exc)}
+            return exception
+
+    async def get_currencies(self) -> Dict:
+        try:
+            uri = self.mono_currencies_uri
+            response = await self.async_request(method="GET", uri=uri)
+            return response
+        except Exception as exc:
+            exception = {"datail": str(exc)}
+            return exception
+
+    async def get_currency(self, ccy: str) -> Dict:
+        try:
+            pair = self.mono_currencies.get(ccy)
+            if pair is not None:
+                currencies = await self.get_currencies()
+                response = self.currency(ccy, pair, currencies)
+            else:
+                response = self.currency_exception()
+            return response
+        except Exception as exc:
+            exception = {"detail": str(exc)}
+            return exception
+
+    async def get_client_info(self) -> Dict:
+        try:
+            uri = self.mono_client_info_uri
+            token = self.token
+            headers = {"X-Token": token}
+            response = await self.async_request(method="GET", uri=uri, headers=headers)
+            return response
+        except Exception as exc:
+            exception = {"detail": str(exc)}
+            return exception
+
+    async def get_balance(self) -> Dict:
+        try:
+            payload = await self.get_client_info()
+            code = payload.get("code")
+            data = payload.get("detail")
+            balance = {"balance": data["accounts"][0]["balance"] / 100}
+            response = self.mono_response(code, balance)
+            return response
+        except Exception:
+            return payload
+
+    async def get_statement(self, period: int) -> Dict:
+        try:
+            uri = self.mono_statement_uri
+            token = self.token
+            headers = {"X-Token": token}
+            time_delta = self.date(period).get("time_delta")
+            response = await self.async_request(
+                method="GET", uri=f"{uri}{time_delta}/", headers=headers
+            )
+            return response
+        except Exception as exc:
+            exception = {"detail": str(exc)}
+            return exception
+
+    async def create_webhook(self, webhook: str) -> Dict:
+        try:
+            uri = self.mono_webhook_uri
+            token = self.token
+            headers = {"X-Token": token}
+            response = await self.async_request(
+                method="POST",
+                uri=uri,
+                headers=headers,
+                data=webhook,
+            )
+            return response
+        except Exception as exc:
+            exception = {"detail": str(exc)}
+            return exception

monobank_api_client/async_mono/manager.py

@@ -0,0 +1,11 @@
+from django.contrib import admin
+from .models import Mono
+
+
+@admin.register(Mono)
+class MonoAdmin(admin.ModelAdmin):
+    list_display = (
+        "user",
+        "mono_token",
+        "date_joined",
+    )

monobank_api_client/drf_mono/__init__.py

@@ -0,0 +1,6 @@
+from django.apps import AppConfig
+
+
+class DrfMonoConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "drf_mono"

monobank_api_client/drf_mono/admin.py

@@ -0,0 +1,43 @@
+# Generated by Django 4.2.7 on 2023-11-29 12:51
+
+from django.conf import settings
+from django.db import migrations, models
+import django.db.models.deletion
+import django.utils.timezone
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="Mono",
+            fields=[
+                (
+                    "id",
+                    models.BigAutoField(
+                        auto_created=True,
+                        primary_key=True,
+                        serialize=False,
+                        verbose_name="ID",
+                    ),
+                ),
+                ("mono_token", models.CharField(max_length=44, unique=True)),
+                (
+                    "date_joined",
+                    models.DateTimeField(default=django.utils.timezone.now),
+                ),
+                (
+                    "user",
+                    models.OneToOneField(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to=settings.AUTH_USER_MODEL,
+                    ),
+                ),
+            ],
+        ),
+    ]

monobank_api_client/drf_mono/apps.py

@@ -0,0 +1,18 @@
+from django.db import models
+from django.utils import timezone
+from django.contrib.auth import get_user_model
+
+User = get_user_model()
+
+
+class Mono(models.Model):
+    mono_token = models.CharField(
+        max_length=44,
+        blank=False,
+        unique=True,
+    )
+    user = models.OneToOneField(User, on_delete=models.CASCADE, unique=True)
+    date_joined = models.DateTimeField(default=timezone.now)
+
+    def __str__(self) -> str:
+        return self.user.email

monobank_api_client/drf_mono/migrations/0001_initial.py

@@ -0,0 +1,21 @@
+from rest_framework import serializers
+from .models import Mono
+
+
+class MonoTokenSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = Mono
+        fields = ["mono_token"]
+        extra_kwargs = {"mono_token": {"write_only": True}}
+
+
+class MonoPeriodSerializer(serializers.Serializer):
+    period = serializers.IntegerField(min_value=0, max_value=31)
+
+
+class WebhookSerializer(serializers.Serializer):
+    webHookUrl = serializers.URLField()
+
+
+class MonoCurrencySerializer(serializers.Serializer):
+    currency = serializers.CharField()