init commit

backend/app/models/__init__.py

@@ -0,0 +1,13 @@
+__all__ = ['SQLModel']
+
+# Initialize all models for SQLModel's __init_subclass__ to trigger
+from sqlmodel import SQLModel
+
+from .base import *
+from .event import *
+from .item import *
+from .ofd import *
+from .telegram import *
+from .tokens import *
+from .transactions import *
+from .user import *

backend/app/models/base.py

@@ -0,0 +1,12 @@
+from uuid import UUID
+
+from pydantic import BaseModel
+
+
+class BasicResponse(BaseModel):
+    detail: str
+
+
+class OfdRequest(BaseModel):
+    ofd_string: str
+    event_id: UUID

backend/app/models/event.py

@@ -0,0 +1,50 @@
+from uuid import UUID
+from uuid import uuid4
+
+from sqlalchemy import BigInteger
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+from sqlmodel import Field
+from sqlmodel import Relationship
+from sqlmodel import SQLModel
+
+from app.models.transactions import Transaction
+
+from .links import EventUserLink
+from .user import User
+
+
+class BaseEvent(SQLModel):
+    name: str = Field(nullable=False, default='Change name pls')
+
+
+class Event(BaseEvent, table=True):
+    id: UUID = Field(primary_key=True, default_factory=uuid4)
+    owner_id: int = Field(
+        sa_column=Column(BigInteger(), ForeignKey('user.id'))
+    )
+    invite: str | None = Field(default_factory=uuid4)
+    users: list['User'] = Relationship(
+        back_populates='events', link_model=EventUserLink
+    )
+    transactions: list['Transaction'] = Relationship(
+        back_populates='event', cascade_delete=True
+    )
+
+    async def add_user(self, user: User):
+        self.users.append(user)
+
+    async def add_transaction(self, transaction: Transaction):
+        self.transactions.append(transaction)
+
+
+class OutputEvent(BaseEvent):
+    id: UUID
+    owner: int
+    users: list[User]
+    invite: str | None
+    name: str
+
+
+class AddUserRequest(SQLModel):
+    user_id: int

backend/app/models/item.py

@@ -0,0 +1,40 @@
+from uuid import UUID
+from uuid import uuid4
+
+from sqlmodel import Field
+from sqlmodel import Relationship
+from sqlmodel import SQLModel
+
+from app.models.user import User
+
+from .links import ItemUserLink
+
+
+class Item(SQLModel, table=True):
+    id: UUID = Field(primary_key=True, default_factory=uuid4)
+    title: str = Field(nullable=False)
+    price: float = Field(nullable=False)
+
+    assigned_to: list['User'] = Relationship(
+        back_populates='items', link_model=ItemUserLink
+    )
+    transaction_id: UUID = Field(foreign_key='transaction.id')
+    transaction: 'Transaction' = Relationship(back_populates='items')
+
+    def assign_user(self, user: User):
+        self.assigned_to.append(user)
+
+
+class OutputItem(SQLModel):
+    id: UUID
+    title: str
+    price: float
+    assigned_to: list['User']
+    transaction_id: UUID
+
+
+class ItemRequest(SQLModel):
+    title: str
+    price: float
+
+    all_users_selected: bool = False

backend/app/models/links.py

@@ -0,0 +1,24 @@
+import uuid
+
+from sqlalchemy import BigInteger
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+import sqlmodel
+
+
+class EventUserLink(sqlmodel.SQLModel, table=True):
+    event_id: uuid.UUID | None = sqlmodel.Field(
+        default=None, foreign_key='event.id', primary_key=True
+    )
+    user_id: int | None = sqlmodel.Field(
+        sa_column=Column(BigInteger(), ForeignKey('user.id'), primary_key=True)
+    )
+
+
+class ItemUserLink(sqlmodel.SQLModel, table=True):
+    item_id: uuid.UUID | None = sqlmodel.Field(
+        default=None, foreign_key='item.id', primary_key=True
+    )
+    user_id: int | None = sqlmodel.Field(
+        sa_column=Column(BigInteger(), ForeignKey('user.id'), primary_key=True)
+    )

backend/app/models/ofd.py

@@ -0,0 +1,61 @@
+from pydantic import BaseModel
+
+
+class OfdRequest(BaseModel):
+    qr_data: str
+
+
+class Item(BaseModel):
+    name: str
+    price: int
+    quantity: int
+    sum: int
+
+
+class Data(BaseModel):
+    user: str
+    retailPlaceAddress: str
+    userInn: str
+    ticketDate: str
+    requestNumber: int
+    shiftNumber: int
+    operator: str
+    operationType: int
+    items: list[Item]
+    nds18: int | None
+    nds10: int | None
+    nds0: int | None
+    ndsNo: int | None
+    totalSum: int
+    cashTotalSum: int | None
+    ecashTotalSum: int | None
+    taxationType: int
+    kktRegId: str
+    kktNumber: str
+    fiscalDriveNumber: str
+    fiscalDocumentNumber: int
+    fiscalSign: int
+
+
+class RequestManual(BaseModel):
+    fn: str
+    fd: str
+    fp: str
+    check_time: str
+    type: int
+    sum: float
+
+
+class Request(BaseModel):
+    qrurl: str
+    qrfile: str
+    qrraw: str
+    manual: RequestManual
+
+
+class OfdResponse(BaseModel):
+    code: int
+    first: int
+    data: Data
+    html: str
+    request: Request

backend/app/models/telegram.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+from pydantic import BaseModel
+
+
+class TelegramWebUser(BaseModel):
+    id: int
+    first_name: str
+    last_name: str | None = ''
+    username: str | None = ''
+    language_code: str | None = ''
+    is_premium: bool = False
+    added_to_attachment_menu: bool = False
+    allows_write_to_pm: bool = False
+    photo_url: str | None = ''
+
+
+class TelegramInputData(BaseModel):
+    query_id: str | None = ''
+    user: TelegramWebUser
+    receiver: Any = ''
+    chat: Any = ''
+    chat_type: str | None = ''
+    chat_instance: str | None = ''
+    start_param: str | None = ''
+    can_send_after: int | None = ''
+    auth_date: int
+    hash: str

backend/app/models/tokens.py

@@ -0,0 +1,6 @@
+import pydantic
+
+
+class Token(pydantic.BaseModel):
+    access_token: str
+    token_type: str

backend/app/models/transactions.py

@@ -0,0 +1,42 @@
+from uuid import UUID
+from uuid import uuid4
+
+from sqlalchemy import BigInteger
+from sqlalchemy import Column
+from sqlalchemy import ForeignKey
+from sqlmodel import Field
+from sqlmodel import Relationship
+from sqlmodel import SQLModel
+
+from app.models.item import Item
+from app.models.user import User
+
+
+class BaseTransaction(SQLModel):
+    title: str = Field(nullable=False)
+
+
+class Transaction(BaseTransaction, table=True):
+    id: UUID = Field(default_factory=uuid4, primary_key=True)
+    payer_id: int = Field(
+        sa_column=Column(BigInteger(), ForeignKey('user.id'))
+    )
+    payer: User = Relationship(back_populates='transactions')
+    event_id: UUID = Field(foreign_key='event.id')
+    event: 'Event' = Relationship(back_populates='transactions')
+    closed: bool = Field(nullable=False, default=False)
+    items: list['Item'] = Relationship(back_populates='transaction')
+
+    async def add_participant(self, participant: User):
+        self.participants.append(participant)
+
+    async def add_item(self, item: Item):
+        self.items.append(item)
+
+
+class OutputTransaction(BaseTransaction):
+    id: UUID
+    payer: User
+    event_id: UUID
+    closed: bool
+    items: list['Item']

backend/app/models/user.py

@@ -0,0 +1,38 @@
+from sqlalchemy import BigInteger
+from sqlalchemy import Column
+from sqlmodel import create_engine
+from sqlmodel import Field
+from sqlmodel import Relationship
+from sqlmodel import Session
+from sqlmodel import SQLModel
+
+from app.core.config import config
+
+from .links import ItemUserLink
+
+
+class User(SQLModel, table=True):
+    id: int = Field(sa_column=Column(BigInteger(), primary_key=True))
+    username: str = Field(nullable=False)
+    events: list['Event'] = Relationship(back_populates='users')
+    items: list['Item'] = Relationship(
+        back_populates='assigned_to', link_model=ItemUserLink
+    )
+    transactions: list['Transaction'] = Relationship(back_populates='payer')
+
+    async def get_or_create_user(self):
+        engine = create_engine(url=config.DATABASE_URL)
+        with Session(engine) as session:
+            user = session.get(User, self.id)
+
+            if not user:
+                user = User(
+                    id=self.id,
+                    username=self.username,
+                )
+                session.add(user)
+                session.commit()
+
+            session.refresh(user)
+
+            return user