Добавлен API Квартплаты

kv/crud.py

@@ -0,0 +1,423 @@
+from sqlalchemy.orm import Session
+from sqlalchemy import text
+from kv.database import get_table
+from kv import schemas
+
+
+def exec_procedure(session, proc_name, params, database: str = None):
+    sql_params = ",".join(["@{0}={1}".format(name, value)
+                           for name, value in params.items()])
+    dbstr = ""
+    if database:
+        dbstr = f"[{database}]."
+    sql_string = """
+        DECLARE @return_value int;
+        EXEC    @return_value = {dbstr}[dbo].[{proc_name}] {params};
+        SELECT 'Return Value' = @return_value;
+    """.format(dbstr=dbstr, proc_name=proc_name, params=sql_params)
+
+    return session.execute(sql_string).fetchall()
+
+
+def exec_procedure_wo_result(session, proc_name, params, database: str = None):
+    sql_params = ",".join(["@{0}={1}".format(name, value)
+                           for name, value in params.items()])
+    dbstr = ""
+    if database:
+        dbstr = f"[{database}]."
+    sql_string = """
+        EXEC   {dbstr}[dbo].[{proc_name}] {params}
+    """.format(dbstr=dbstr, proc_name=proc_name, params=sql_params)
+    session.execute(sql_string)
+    session.commit()
+
+
+"""PersonalAccountViewSet"""
+
+
+class PersonalAccountViewSet:
+    def get_turn_over(db: Session, data: schemas.PersonalAccountInit = None):
+        return exec_procedure(db, 'uspGetPersonalAccountTurnOver', **data)
+
+    def get_details(db: Session, id: int = None):
+        table = get_table("PersonalAccount")
+        return db.query(table).filter(table.c["ID"] == id).first()
+
+    def get_services(db: Session, IDPersonalAccount: int = None):
+        return exec_procedure(db, 'uspGetPersonalAccountServices', {'IDPersonalAccount': IDPersonalAccount})
+
+    def get_debt(db: Session, data: schemas.PersonalAccount = None):
+        return exec_procedure(db, 'uspGetPersonalAccountDebt', **data)
+
+    def get_debts(db: Session, data: schemas.PersonalAccountType = None):
+        return exec_procedure(db, 'uspGetPersonalAccountDebts', **data)
+
+    def get_financial_account(db: Session, data: schemas.PersonalAccountReportTOFinancialInit = None):
+        return exec_procedure(db, 'uspGetPersonalAccountReportTOFinancialAccount', **data)
+
+
+"""AddressInfoViewSet"""
+
+
+class AddressInfoViewSet:
+    """get"""
+
+    def get_details(db: Session, id: int = None):
+        table = get_table("RefAddresses", "General")
+        return db.query(table).filter(table.c["ID"] == id).first()
+
+    def get_personal_accounts(db: Session, IDCity: int = None):
+        return exec_procedure(db, 'uspGetPersonalAccountsList', {'IDCity': IDCity})
+
+    def get_addresses(db: Session, IDCity: int = None):
+        return exec_procedure(db, 'uspGetAddressesByCity', {'IDCity': IDCity})
+
+    def get_address_personal_accounts(db: Session, IDAddress: int = None):
+        return exec_procedure(db, 'uspGetAddressPersonalAccounts', {'IDAddress': IDAddress})
+
+    def retrieve(db: Session, id: int = None):
+        return exec_procedure(db, 'uspGetAddressAndObjectDetails', {'ID': id})
+
+    def get_metering_devices(db: Session, IDAddress: int = None):
+        return exec_procedure(db, 'uspGetAddressMeteringDevices', {'IDAddress': IDAddress})
+
+    """post"""
+
+    def edit(db: Session, data: schemas.EditAdressInit = None):
+        try:
+            exec_procedure_wo_result(db, 'uspEditAddress', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+    def edit_personal_account(db: Session, data: schemas.PersonalAccountDetailsSerializer = None):
+        try:
+            exec_procedure_wo_result(db, 'uspEditPersonalAccount', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+    def edit_personal_account_address(db: Session, data: schemas.EditPersonalAccountAddressInit = None):
+        try:
+            exec_procedure_wo_result(
+                db, 'uspEditPersonalAccountAddress', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+
+"""ObjectViewSet"""
+
+
+class ObjectViewSet:
+    """get"""
+
+    def get_details(db: Session, IDObject: str = None):
+        return exec_procedure(db, 'uspGetPersonalAccountServices', {'IDObject': IDObject})
+
+    def get_municipals(db: Session, IDCity: int = None):
+        return exec_procedure(db, 'uspGetObjectMunicipals', {'IDCity': IDCity})
+
+    def get_services(db: Session, IDObject: str = None):
+        return exec_procedure(db, 'uspGetObjectMunicipals', {'IDObject': IDObject})
+
+    def get_addresses(db: Session, IDObject: str = None):
+        return exec_procedure(db, 'uspGetObjectAddresses', {'IDObject': IDObject})
+
+    def get_metering_devices(db: Session, IDObject: str = None):
+        return exec_procedure(db, 'uspGetObjectMeteringDevices', {'IDObject': IDObject})
+
+    """post"""
+
+    def edit(db: Session, data: schemas.ObjectDetailsSerializer = None):
+        try:
+            exec_procedure_wo_result(db, 'uspEditObject', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+    def edit_service(db: Session, data: schemas.EditObjectServiceInit = None):
+        try:
+            exec_procedure_wo_result(db, 'uspEditObject', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+    def edit_temp_metering_device_address(db: Session, data: schemas.EditTempMeteringDeviceAddressInit = None):
+        try:
+            exec_procedure_wo_result(
+                db, 'uspEditTempMeteringDeviceAddress', **data, database='General')
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+    def add_object(db: Session, data: schemas.AddObjectInit = None):
+        try:
+            exec_procedure_wo_result(db, 'uspAddObject', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+
+"""TurnOverViewSet"""
+
+
+class TurnOverViewSet:
+    """get"""
+
+    """post"""
+
+    def get_to_archive(db: Session, data: schemas.ArchiveInit = None):
+        return exec_procedure(db, 'uspGetTOArchive', **data)
+
+    def make_storno(db: Session, data: schemas.StronoInit = None):
+        try:
+            exec_procedure_wo_result(db, 'uspStorno', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+
+"""PaymentViewSet"""
+
+
+class PaymentViewSet:
+    """get"""
+
+    def get_money_types(db: Session):
+        return db.query(get_table('RefMoneyTypes', 'General')).all()
+
+    def get_worker_types(db: Session):
+        return db.query(get_table('RefWorkerTypes', 'General')).all()
+
+    def get_payer_category_types(db: Session):
+        return db.query(get_table('RefPayerCategoryTypes', 'General')).all()
+
+    def get_services_additional(db: Session):
+        uslugi_tb = get_table('uslugi', 'spr')
+        data_query = db.query(uslugi_tb).filter(uslugi_tb.c["vid_usl"] == 2).order_by(
+            uslugi_tb.c["name"]).with_entities(uslugi_tb.c["kod"].label("ID"), uslugi_tb.c["name"].label("Name"))
+        return data_query.all()
+    """post"""
+
+    def get_receipt_calculate(db: Session, data: schemas.RecieptCalculateInit):
+        return exec_procedure(db, 'uspGetReceiptCalculate', **data)
+
+    def save_receipt(db: Session, data: schemas.ReceiptSaveInit = None):
+        try:
+            exec_procedure_wo_result(db, 'uspSaveReceipt', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+    def repayment_info(db: Session, data: schemas.RepaymentInfoInit):
+        return exec_procedure(db, 'uspGetRepaymentInfo', **data)
+
+    def repayment(db: Session, data: schemas.RepaymentInit):
+        return exec_procedure(db, 'uspRepayment', **data)
+
+
+"""ReportViewSet"""
+
+
+class ReportViewSet:
+    """get"""
+
+    """post"""
+
+    def repayment(db: Session, data: schemas.RentRegisterNoticeInit):
+        return exec_procedure(db, 'uspGetRentRegisterNotices', **data)
+
+
+"""ReportFilterViewSet"""
+
+
+class ReportFilterViewSet:
+    """get"""
+
+    """post"""
+
+    def get_report_filter_types(db: Session, data: schemas.UserInit):
+        return exec_procedure(db, 'uspGetRentRegisterNotices', **data)
+
+    def get_report_filtered_list(db: Session, data: schemas.ReportFilterInit):
+        return exec_procedure(db, 'uspGetReportFilterList', **data)
+
+    def set_report_filter_list(db: Session, data: schemas.ReportFilterSetInit):
+        return exec_procedure_wo_result(db, 'uspSetFilterList', **data)
+
+
+"""AccrualViewSet"""
+
+
+class AccrualViewSet:
+    """get"""
+
+    def get_municipals(db: Session, data: schemas.AccountInit):
+        return exec_procedure(db, 'uspCalculateAccrued', **data)
+
+    """post"""
+
+
+"""WithdrawingViewSet"""
+
+
+class WithdrawingViewSet:
+    """get"""
+
+    def get_withdrawing_types(db: Session):
+        return db.query(get_table('RefWithdrawingTypes', 'General')).all()
+
+    """post"""
+
+    def set_report_filter_list(db: Session, data: schemas.WithdrawingCheckInit):
+        return exec_procedure(db, 'uspGetWithdrawingCheck', **data)
+
+    def get_withdrawing_temp(db: Session, data: schemas.WithdrawingTempInit):
+        return exec_procedure(db, 'uspGetWithdrawingTemp', **data)
+
+    def save_withdrawing(db: Session, data: schemas.WithdrawingSave = None):
+        try:
+            exec_procedure_wo_result(db, 'uspSaveWithdrawing', **data)
+            return {'msg': 'success'}
+        except:
+            return {'msg': 'error'}
+
+
+"""ReferenceViewSet"""
+
+
+class ReferenceViewSet:
+    """get"""
+
+    def get_personal_accounts(db: Session):
+        tb = get_table('PersonalAccount')
+        return db.query(tb).with_entities(tb.c["ID"]).all()
+
+    def get_objects(db: Session, data: schemas.CityInit):
+        return exec_procedure(db, 'uspGetObjects', **data)
+
+    def get_services(db: Session):
+        tb = get_table('uslugi', 'spr')
+        query = db.query(tb).with_entities(
+            tb.c["kod"].label("ID"), tb.c["name"].label("Name"))
+        return query.all()
+
+    def get_provider_types(db: Session):
+        tb = get_table('RefProviderTypes', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_providers(db: Session):
+        tb = get_table('RefProviders', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_systems_water(db: Session):
+        tb = get_table('RefSystemsWater')
+        return db.query(tb).all()
+
+    def get_systems_water_period_types(db: Session):
+        tb = get_table('RefSystemsWaterPeriodTypes')
+        return db.query(tb).all()
+
+    def get_provider_contracts(db: Session, data: schemas.PAInit):
+        return exec_procedure(db, 'uspGetProviderContracts', **data)
+
+    def get_providers_utility_services(db: Session, data: schemas.CityInit):
+        tb = get_table('RefProvidersUtilityServices', 'General')
+        data_query = db.query(tb).filter(tb.c["IDCity"] == data.IDCity).with_entities(
+            tb.c["ID"], tb.c["ShortName"].label("Name"))
+        return data_query.all()
+
+    def get_management_companies(db: Session):
+        tb = get_table('RefManagementCompany', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_boilers_by_city(db: Session, data: schemas.CityInit):
+        tb = get_table('vBoilers', 'General')
+        data_query = db.query(tb).filter(tb.c["id_city"] == data.IDCity).with_entities(
+            tb.c["ID"], tb.c["Name"])
+        return data_query.all()
+
+    def get_streets_by_city(db: Session, data: schemas.CityInit):
+        tb = get_table('vStreets', 'General')
+        data_query = db.query(tb).filter(tb.c["id_city"] == data.IDCity).with_entities(
+            tb.c["ID"], tb.c["Name"])
+        return data_query.all()
+
+    def get_metering_devices_services(db: Session):
+        qu = text(
+            "select kod ID, case when kod=3 then 'Горячая вода' else sname end Name from spr..uslugi where uchet=1 order by kod")
+        return db.execute(qu).fetchall()
+
+    def get_owhership_types(db: Session):
+        tb = get_table('RefObjectOwnershipTypes', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_object_improvement_degree_types(db: Session):
+        tb = get_table('RefObjectImprovementDegreeTypes', 'General')
+        return db.query(tb).all()
+
+    def get_object_gas_types(db: Session):
+        tb = get_table('RefObjectGasTypes', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_object_heating_types(db: Session):
+        tb = get_table('RefObjectHeatingTypes', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_object_wiring_types(db: Session):
+        tb = get_table('RefObjectWiringTypes', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_object_wall_material_types(db: Session):
+        tb = get_table('RefObjectWallMaterialTypes', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_object_roof_types(db: Session):
+        tb = get_table('RefObjectRoofTypes', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_object_foundation_types(db: Session):
+        tb = get_table('RefObjectFoundationTypes', 'General')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_tariffs_population(db: Session):
+        tb = get_table('TariffPopulation')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_courts_types(db: Session):
+        tb = get_table('RefCourtsTypes')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    def get_address_types(db: Session):
+        tb = get_table('RefAddressType')
+        return db.query(tb).with_entities(tb.c["ID"], tb.c["Name"]).all()
+
+    """post"""
+
+    def get_advanced_search(db: Session, data: schemas.AdvancedSearchInit):
+        return exec_procedure(db, 'uspGetAdvancedSearch', **data)
+
+    def get_metering_devices_types(db: Session, data: schemas.ServiceIDInit):
+        tb = get_table('RefMeteringDevicesTypes', 'General')
+        data_query = db.query(tb).filter(tb.c["IDService"] == data.IDService).order_by(
+            tb.c["Name"]).with_entities(tb.c["ID"], tb.c["Name"])
+        return data_query.all()
+
+    def get_object_metering_devices_types(db: Session, data: schemas.ObjectMeteringDevicesTypesInit):
+        return exec_procedure(db, 'uspGetMeteringDeviceTypes', params=data, database='General')
+
+    def get_object_metering_device_addresses(db: Session, data: schemas.ObjectMeteringDeviceAddressInit):
+        return exec_procedure(db, 'uspGetMeteringDeviceTypes', params=data, database='General')
+
+    def get_object_water_system_volumes(db: Session, data: schemas.ObjectWaterSystemVolumesInit):
+        return exec_procedure(db, 'uspGetObjectWaterSystemVolumes', **data)
+
+    def get_tariff_population(db: Session, data: schemas.TariffsPopulationInit):
+        return exec_procedure(db, 'uspGetTariffsPopulation', **data)
+
+    def get_object_tariff_provider(db: Session, data: schemas.TariffProviderInit):
+        return exec_procedure(db, 'uspGetObjectTariffProvider', **data)
+
+    def edit_metering_device(db: Session, data: schemas.MeteringDeviceInit):
+        return exec_procedure_wo_result(db, 'uspEditMeteringDevice', **data)

kv/database.py

@@ -0,0 +1,61 @@
+from sqlalchemy import create_engine, Table
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from typing import Optional, Dict
+from dataclasses import dataclass
+import json
+
+
+@dataclass
+class Database:
+    engine: str
+    name: str
+    host: str
+    user: str
+    password: str
+    options: Optional[Dict] = None
+
+    def get_url(self):
+        option_str = ""
+        if self.options:
+            opt = [name+'='+'+'.join(value.split())
+                   for name, value in self.options.items()]
+            option_str = "?"+"&".join(opt)
+        return f"{self.engine}://{self.user}:{self.password}@{self.host}/{self.name}{option_str}"
+
+
+data = {}
+
+with open('settings', 'r') as settings:
+    data_str = settings.read()
+    data = json.loads(data_str)
+db = Database(**data.get('database'))
+
+SQL_ALCHEMY_DATABASE_URL_MSSQL = db.get_url()
+
+
+engine = create_engine(
+    SQL_ALCHEMY_DATABASE_URL_MSSQL, connect_args={"check_same_thread": False}
+)
+
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+
+Base = declarative_base()
+
+
+def get_table(tablename: str, dbname: str = None) -> Table:
+    metadata = Base.metadata
+    metadata.reflect(bind=engine)
+
+    if dbname == None:
+        dbname = db.name
+
+    return Table(tablename, metadata, schema=dbname+'.dbo', autoload=True, autoload_with=engine)
+
+
+def get_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

kv/general/models/general.py

@@ -1,24 +0,0 @@
-from sqlalchemy import Boolean, Column, ForeignKey, Integer, String
-from sqlalchemy.orm import relationship
-
-from databases.mssql.database import Base
-
-
-class Region(Base):
-    __tablename__ = "regions"
-
-    id = Column( Integer, primary_key= True, index= True)
-    name = Column(String(255))
-    active = Column(Boolean, default=True)
-
-
-
-class City(Base):
-    __tablename__ = "cities"
-
-    id = Column(Integer, autoincrement= True, primary_key= True, index= True)
-    name = Column(String(255))
-    region_id = Column(Integer, ForeignKey(regions.id))
-    active = Column(Boolean, default= True)
-
-

kv/general/schemas/general.py

@@ -1,3 +0,0 @@
-from typing import List, Optional
-
-from pydantic import BaseModel

kv/isapi.py

@@ -0,0 +1,53 @@
+from fastapi import Depends, APIRouter
+from requests import Session
+from kv.routers import address, objectvs, payment, personalaccount, reference, report, accrual, reportfilter, turnover, withdrawing
+from kv.database import get_db, get_table
+from typing import List
+from kv import schemas
+
+
+router = APIRouter()
+def exec_procedure(session, proc_name, params, database: str = None):
+    sql_params = ""
+    if params:
+        sql_params = ",".join(["@{0}={1}".format(name, value)
+                               for name, value in params.items()])
+    dbstr = ""
+    if database:
+        dbstr = f"[{database}]."
+    sql_string = """
+        DECLARE @return_value int;
+        EXEC    @return_value = {dbstr}[dbo].[{proc_name}] {params};
+        SELECT 'Return Value' = @return_value;
+    """.format(dbstr=dbstr, proc_name=proc_name, params=sql_params)
+    print(sql_string)
+    return session.execute(sql_string).fetchall()
+
+
+
+
+
+@router.get("/get_settings", response_model=List[schemas.SettingsSerializer])
+async def get_settings(db: Session = Depends(get_db)):
+    table = get_table("vSettings")
+    return db.query(table).all()
+
+router.include_router(address.router,prefix="/address-info", tags=["AddressInfoViewSet"] )
+
+router.include_router(objectvs.router, prefix="/object", tags=["ObjectViewSet"])
+
+router.include_router(payment.router, prefix="/payment", tags=["PaymentViewSet"])
+
+router.include_router(personalaccount.router, prefix="/personal-account", tags=["PersonalAccountViewSet"])
+
+router.include_router(reference.router, prefix="/reference", tags=["ReferenceViewSet"])
+
+router.include_router(report.router, prefix="/report", tags=["ReportViewSet"])
+
+router.include_router(reportfilter.router, prefix="/reportfilter", tags=["ReportFilterViewSet"])
+
+router.include_router(turnover.router, prefix="/turnover", tags=["TurnOverViewSet"])
+
+router.include_router(withdrawing.router, prefix="/withdrawing", tags=["WithdrawingViewSet"])
+
+router.include_router(accrual.router,prefix="/accrual", tags=["AccrualViewSet"])

kv/kv.py

@@ -1,9 +1,14 @@
 from fastapi import APIRouter, Depends
 from auth import oauth2
 from auth.login.schemas import login as schemas
-from kv.routers import general
+
+from kv import isapi
 
 router = APIRouter()
 
-router.include_router(general.router)
+router.include_router(
+    router=isapi.router,
+    prefix="",
+    responses={404: {"description": "IS is Not found"}}
+)
 

kv/routers/accrual.py

@@ -0,0 +1,13 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from kv.database import get_db
+router = APIRouter()
+
+"""get"""
+
+
+@router.get("/get_municipals")
+def get_municipals(db: Session = Depends(get_db)):
+    return crud.AccrualViewSet.get_municipals(db)

kv/routers/address.py

@@ -0,0 +1,65 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+
+router = APIRouter()
+
+"""get"""
+
+
+@router.get("/get_details/{id}", response_model=List[schemas.AddressDetailsSerializer])
+def get_details(id: int, db: Session = Depends(get_db)):
+    data = crud.AddressInfoViewSet.get_details(db, id)
+    return data
+
+
+@router.get("/get_personal_accounts/{IDCity}", response_model=List[schemas.PersonalAccountSerializer])
+def get_personal_accounts(IDCity: int, db: Session = Depends(get_db)):
+    data = crud.AddressInfoViewSet.get_personal_accounts(
+        db, IDCity=IDCity)
+    return data
+
+
+@router.get("/get_addresses/{IDCity}", response_model=List[schemas.AddressesSerializer])
+def get_addresses(IDCity: int, db: Session = Depends(get_db)):
+    data = crud.AddressInfoViewSet.get_addresses(db, IDCity)
+    return data
+
+
+@router.get("/get_address_personal_accounts/{IDAddress}", response_model=List[schemas.AddressPersonalAccounts])
+def get_address_personal_accounts(IDAddress: int, db: Session = Depends(get_db)):
+    data = crud.AddressInfoViewSet.get_address_personal_accounts(db, IDAddress)
+    return data
+
+
+@router.get("/retrieve/{id}", response_model=List[schemas.AddressDetailInfoSerializer])
+def retrieve(id: int, db: Session = Depends(get_db)):
+    data = crud.AddressInfoViewSet.retrieve(db, id)
+    return data
+
+
+@router.get("/get_metering_devices/{IDAddress}", response_model=List[schemas.AddressMeteringDevices])
+def get_metering_devices(IDAddress: int, db: Session = Depends(get_db)):
+    data = crud.AddressInfoViewSet.get_metering_devices(db, IDAddress)
+    return data
+
+
+"""post"""
+
+
+@router.post('/edit')
+def edit(request: schemas.EditAdressInit, db: Session = Depends(get_db)):
+    return crud.AddressInfoViewSet.edit(db, request)
+
+
+@router.post('/edit_personal_account')
+def edit_personal_account(request: schemas.PersonalAccountDetailsSerializer, db: Session = Depends(get_db)):
+    return crud.AddressInfoViewSet.edit_personal_account(db, request)
+
+
+@router.post('/edit_personal_account')
+def edit_personal_account(request: schemas.PersonalAccountDetailsSerializer, db: Session = Depends(get_db)):
+    return crud.AddressInfoViewSet.edit_personal_account(db, request)

kv/routers/general.py

@@ -1,27 +0,0 @@
-from fastapi import APIRouter, Depends
-from auth.login.schemas import login as models
-from auth import oauth2
-from databases.mssql import general
-
-router = APIRouter(dependencies= [Depends(oauth2.get_current_user) ])
-
-@router.get('/')
-async def test_router():
-    return {"msg":"router!"}
-
-@router.get('/getCities')
-def get_cities(db = Depends(general.get_db)):
-    return db.execute("SELECT id,name FROM General.dbo.vCities").fetchall()
-
-@router.get('/getCities/region-id={region_id}')
-def get_city(region_id: int,db = Depends(general.get_db)):
-    return db.execute(f"SELECT id, name FROM General.dbo.vCities WHERE id_region = {region_id}").fetchall()
-
-
-@router.get('/getAddress/city-id={city_id}')
-def get_address(city_id: int, db= Depends(general.get_db)):
-    return db.execute(f"EXEC General.dbo.getAddress @city_id = {city_id}").fetchall()
-
-@router.get('/getRegions')
-def get_region(db = Depends(general.get_db)):
-    return db.execute("SELECT id, name FROM General.dbo.vRegions").fetchall()

kv/routers/objectvs.py

@@ -0,0 +1,62 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+router = APIRouter()
+
+"""get"""
+
+
+@router.get("/get_details/{IDObject}", response_model=List[schemas.ObjectDetailsSerializer])
+def get_details(IDObject: str, db: Session = Depends(get_db)):
+    data = crud.ObjectViewSet.get_details(db, IDObject)
+    return data
+
+
+@router.get("/get_municipals/{IDCity}", response_model=List[schemas.ObjectMunicipalsSerializer])
+def get_municipals(IDCity: int, db: Session = Depends(get_db)):
+    data = crud.ObjectViewSet.get_municipals(db, IDCity)
+    return data
+
+
+@router.get("/get_services/{IDObject}", response_model=List[schemas.ObjectServicesSerializer])
+def get_services(IDObject: str, db: Session = Depends(get_db)):
+    data = crud.ObjectViewSet.get_services(db, IDObject)
+    return data
+
+
+@router.get("/get_addresses/{IDObject}", response_model=List[schemas.ObjectAddressesSerializer])
+def get_addresses(IDObject: str, db: Session = Depends(get_db)):
+    data = crud.ObjectViewSet.get_addresses(db, id)
+    return data
+
+
+@router.get("/get_metering_devices/{IDObject}", response_model=List[schemas.ObjectMeteringDevicesSerializer])
+def get_metering_devices(IDObject: str, db: Session = Depends(get_db)):
+    data = crud.ObjectViewSet.get_metering_devices(db, IDObject)
+    return data
+
+
+"""post"""
+
+
+@router.post('/edit')
+def edit(request: schemas.ObjectDetailsSerializer, db: Session = Depends(get_db)):
+    return crud.ObjectViewSet.edit(db, request)
+
+
+@router.post('/edit_service')
+def edit_service(request: schemas.EditObjectServiceInit, db: Session = Depends(get_db)):
+    return crud.ObjectViewSet.edit_service(db, request)
+
+
+@router.post('/edit_temp_metering_device_address')
+def edit_temp_metering_device_address(request: schemas.EditTempMeteringDeviceAddressInit, db: Session = Depends(get_db)):
+    return crud.ObjectViewSet.edit_temp_metering_device_address(db, request)
+
+
+@router.post('/add_object')
+def add_object(request: schemas.AddObjectInit, db: Session = Depends(get_db)):
+    return crud.ObjectViewSet.add_object(db, request)

kv/routers/payment.py

@@ -0,0 +1,56 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+router = APIRouter()
+
+"""get"""
+
+
+@router.get("/get_money_types", response_model=List[schemas.MoneyTypesSerializer])
+def get_money_types(db: Session = Depends(get_db)):
+    data = crud.PaymentViewSet.get_money_types(db)
+    return data
+
+
+@router.get("/get_worker_types", response_model=List[schemas.WorkerTypesSerializer])
+def get_worker_types(db: Session = Depends(get_db)):
+    data = crud.PaymentViewSet.get_worker_types(db)
+    return data
+
+
+@router.get("/get_payer_category_types", response_model=List[schemas.PayerCategoryTypesSerializer])
+def get_payer_category_types(db: Session = Depends(get_db)):
+    data = crud.PaymentViewSet.get_payer_category_types(db)
+    return data
+
+
+@router.get("/get_services_additional", response_model=List[schemas.ServicesAdditionalSerializer])
+def get_services_additional(db: Session = Depends(get_db)):
+    data = crud.PaymentViewSet.get_services_additional(db)
+    return data
+
+
+"""post"""
+
+
+@router.post('/get_receipt_calculate', response_model=List[schemas.ReceiptCalculatedSerializer])
+def get_receipt_calculate(request: schemas.RecieptCalculateInit, db: Session = Depends(get_db)):
+    return crud.PaymentViewSet.get_receipt_calculate(db, request)
+
+
+@router.post('/save_receipt')
+def save_receipt(request: schemas.ReceiptSaveInit, db: Session = Depends(get_db)):
+    return crud.PaymentViewSet.save_receipt(db, request)
+
+
+@router.post('/repayment_info', response_model=List[schemas.RentRepaymentInfoSerializer])
+def repayment_info(request: schemas.RepaymentInfoInit, db: Session = Depends(get_db)):
+    return crud.PaymentViewSet.repayment_info(db, request)
+
+
+@router.post('/repayment', response_model=List[schemas.RentRepaymentSerializer])
+def repayment(request: schemas.RepaymentInit, db: Session = Depends(get_db)):
+    return crud.PaymentViewSet.repayment(db, request)

kv/routers/personalaccount.py

@@ -0,0 +1,50 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+router = APIRouter()
+
+"""get"""
+
+
+@router.get("/get_details/{id}", response_model=List[schemas.PersonalAccountDetailsSerializer])
+def get_details(id: int, db: Session = Depends(get_db)):
+    data = crud.PersonalAccountViewSet.get_details(db, id)
+    return data
+
+
+@router.get("/get_turn_over/{IDPersonalAccount}", response_model=List[schemas.TurnOverSerializer])
+def get_turn_over(IDPersonalAccount: int, db: Session = Depends(get_db)):
+    data = crud.PersonalAccountViewSet.get_turn_over(db, IDPersonalAccount)
+    return data
+
+
+@router.get("/get_services/{IDPersonalAccount}", response_model=List[schemas.PersonalAccountTOServicesSerializer])
+def get_services(IDPersonalAccount: int, db: Session = Depends(get_db)):
+    data = crud.PersonalAccountViewSet.get_services(db, IDPersonalAccount)
+    return data
+
+
+@router.get("/get_debt/{IDPersonalAccount}", response_model=List[schemas.PersonalAccountDebtSerilizer])
+def get_debt(IDPersonalAccount: int, db: Session = Depends(get_db)):
+    data = crud.PersonalAccountViewSet.get_debt(db, IDPersonalAccount)
+    return data
+
+
+@router.get("/get_debts/IDPersonalAccount={IDPersonalAccount},GetType={GetType}", response_model=List[schemas.PersonalAccountDebtsSerializer])
+def get_debts(IDPersonalAccount: int, GetType: bool, db: Session = Depends(get_db)):
+    to_data = schemas.PersonalAccountType(
+        IDPersonalAccount=IDPersonalAccount, GetType=GetType)
+    data = crud.PersonalAccountViewSet.get_debts(db, to_data)
+    return data
+
+
+"""post"""
+
+
+@router.post("/get_financial_account", response_model=List[schemas.ReportTOFinancialAccount])
+def get_financial_account(request: schemas.PersonalAccountInit, db: Session = Depends(get_db)):
+    data = crud.PersonalAccountViewSet.get_financial_account(db, request)
+    return schemas.ReportTOFinancialAccount(**data)

kv/routers/reference.py

@@ -0,0 +1,213 @@
+import kv.schemas as schemas
+from kv.crud import ReferenceViewSet
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+router = APIRouter()
+
+"""get"""
+
+
+@router.get("/get_personal_accounts", response_model=List[schemas.PersonalAccountsSerializer])
+def get_personal_accounts(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_personal_accounts(db)
+    return data
+
+
+@router.get("/get_objects/{IDCity}", response_model=List[schemas.ObjectsSerializer])
+def get_objects(IDCity: int, db: Session = Depends(get_db)):
+    inn = schemas.CityInit(IDCity=IDCity)
+    data = ReferenceViewSet.get_objects(db, inn)
+    return data
+
+
+@router.get("/get_services", response_model=List[schemas.CommonTypeSerializer])
+def get_services(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_services(db)
+    return data
+
+
+@router.get("/get_provider_types", response_model=List[schemas.ProviderTypeSerializer])
+def get_provider_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_provider_types(db)
+    return data
+
+
+@router.get("/get_providers", response_model=List[schemas.CommonTypeSerializer])
+def get_providers(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_providers(db)
+    return data
+
+
+@router.get("/get_systems_water", response_model=List[schemas.SystemWater])
+def get_systems_water(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_systems_water(db)
+    return data
+
+
+@router.get("/get_systems_water_period_types", response_model=List[schemas.SystemWaterPeriodType])
+def get_systems_water_period_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_systems_water_period_types(db)
+    return data
+
+
+@router.get("/get_provider_contracts/{IDPersonalAccount}", response_model=List[schemas.ProviderContractSerializer])
+def get_provider_contracts(IDPersonalAccount: int, db: Session = Depends(get_db)):
+    inn = schemas.PAInit(IDPersonalAccount=IDPersonalAccount)
+    data = ReferenceViewSet.get_provider_contracts(db, inn)
+    return data
+
+
+@router.get("/get_providers_utility_services/{IDCity}", response_model=List[schemas.CommonTypeSerializer])
+def get_providers_utility_services(IDCity: int, db: Session = Depends(get_db)):
+    inn = schemas.CityInit(IDCity=IDCity)
+    data = ReferenceViewSet.get_providers_utility_services(db, inn)
+    return data
+
+
+@router.get("/get_management_companies", response_model=List[schemas.ManagementCompanySerializer])
+def get_management_companies(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_management_companies(db)
+    return data
+
+
+@router.get("/get_boilers_by_city/{IDCity}", response_model=List[schemas.CommonTypeUUIDSerializer])
+def get_boilers_by_city(IDCity: int, db: Session = Depends(get_db)):
+    inn = schemas.CityInit(IDCity=IDCity)
+    data = ReferenceViewSet.get_boilers_by_city(db, inn)
+    return data
+
+
+@router.get("/get_streets_by_city/{IDCity}", response_model=List[schemas.CommonTypeSerializer])
+def get_streets_by_city(IDCity: int, db: Session = Depends(get_db)):
+    inn = schemas.CityInit(IDCity=IDCity)
+    data = ReferenceViewSet.get_streets_by_city(db, inn)
+    return data
+
+
+@router.get("/get_metering_devices_services", response_model=List[schemas.ServicesSerializer])
+def get_metering_devices_services(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_metering_devices_services(db)
+    return data
+
+
+@router.get("/get_owhership_types", response_model=List[schemas.OwnershipType])
+def get_owhership_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_owhership_types(db)
+    return data
+
+
+@router.get("/get_object_improvement_degree_types", response_model=List[schemas.ImprovementDegreeSerializer])
+def get_object_improvement_degree_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_object_improvement_degree_types(db)
+    return data
+
+
+@router.get("/get_object_gas_types", response_model=List[schemas.CommonTypeSerializer])
+def get_object_gas_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_object_gas_types(db)
+    return data
+
+
+@router.get("/get_object_heating_types", response_model=List[schemas.CommonTypeSerializer])
+def get_object_heating_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_object_heating_types(db)
+    return data
+
+
+@router.get("/get_object_wiring_types", response_model=List[schemas.CommonTypeSerializer])
+def get_object_wiring_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_object_wiring_types(db)
+    return data
+
+
+@router.get("/get_object_overlapping_types", response_model=List[schemas.CommonTypeSerializer])
+def get_object_overlapping_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_object_overlapping_types(db)
+    return data
+
+
+@router.get("/get_object_wall_material_types", response_model=List[schemas.CommonTypeSerializer])
+def get_object_wall_material_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_object_wall_material_types(db)
+    return data
+
+
+@router.get("/get_object_roof_types", response_model=List[schemas.CommonTypeSerializer])
+def get_object_roof_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_object_roof_types(db)
+    return data
+
+
+@router.get("/get_object_foundation_types", response_model=List[schemas.CommonTypeSerializer])
+def get_object_foundation_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_object_foundation_types(db)
+    return data
+
+
+@router.get("/get_tariffs_population", response_model=List[schemas.CommonTypeSerializer])
+def get_tariffs_population(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_tariffs_population(db)
+    return data
+
+
+@router.get("/get_tariffs_population", response_model=List[schemas.CommonTypeSerializer])
+def get_tariffs_population(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_tariffs_population(db)
+    return data
+
+
+@router.get("/get_courts_types", response_model=List[schemas.CommonTypeSerializer])
+def get_courts_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_courts_types(db)
+    return data
+
+
+@router.get("/get_address_types", response_model=List[schemas.CommonTypeSerializer])
+def get_address_types(db: Session = Depends(get_db)):
+    data = ReferenceViewSet.get_address_types(db)
+    return data
+
+
+"""post"""
+
+
+@router.post('/get_advanced_search', response_model=List[schemas.AdvancedSearchSerializer])
+def get_advanced_search(request: schemas.AdvancedSearchInit, db: Session = Depends(get_db)):
+    return ReferenceViewSet.edit(db, request)
+
+
+@router.post('/get_metering_devices_types', response_model=List[schemas.MeteringDeviceTypeSerializer])
+def get_metering_devices_types(request: schemas.ServiceIDInit, db: Session = Depends(get_db)):
+    return ReferenceViewSet.get_metering_devices_types(db, request)
+
+
+@router.post('/get_object_metering_devices_types', response_model=List[schemas.CommonTypeSerializer])
+def get_object_metering_devices_types(request: schemas.ObjectMeteringDevicesTypesInit, db: Session = Depends(get_db)):
+    return ReferenceViewSet.get_object_metering_devices_types(db, request)
+
+
+@router.post('/get_object_metering_device_addresses', response_model=List[schemas.ObjectMeteringDeviceAddressesSerializer])
+def get_object_metering_device_addresses(request: schemas.AdvancedSearchInit, db: Session = Depends(get_db)):
+    return ReferenceViewSet.get_object_metering_device_addresses(db, request)
+
+
+@router.post('/get_object_water_system_volumes', response_model=List[schemas.CommonTypeSerializer])
+def get_object_water_system_volumes(request: schemas.TariffsPopulationInit, db: Session = Depends(get_db)):
+    return ReferenceViewSet.get_object_water_system_volumes(db, request)
+
+
+@router.post('/get_tariff_population', response_model=List[schemas.TariffPopulationSerializer])
+def get_tariff_population(request: schemas.AdvancedSearchInit, db: Session = Depends(get_db)):
+    return ReferenceViewSet.get_tariff_population(db, request)
+
+
+@router.post('/get_object_tariff_provider', response_model=List[schemas.TariffProviderSerializer])
+def get_object_tariff_provider(request: schemas.TariffProviderInit, db: Session = Depends(get_db)):
+    return ReferenceViewSet.get_object_tariff_provider(db, request)
+
+
+@router.post('/edit_metering_device')
+def edit_metering_device(request: schemas.MeteringDeviceInit, db: Session = Depends(get_db)):
+    return ReferenceViewSet.edit_metering_device(db, request)

kv/routers/report.py

@@ -0,0 +1,15 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+router = APIRouter()
+
+"""post"""
+
+
+@router.post("/repayment", response_model=List[schemas.RentRegisterNotices])
+def repayment(request: schemas.RentRegisterNoticeInit, db: Session = Depends(get_db)):
+    data = crud.ReportViewSet.get_details(db, request)
+    return data

kv/routers/reportfilter.py

@@ -0,0 +1,24 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+router = APIRouter()
+
+"""post"""
+
+
+@router.post('/get_report_filter_types', response_model=List[schemas.ReportFilterTypeSerializer])
+def get_report_filter_types(request: schemas.UserInit, db: Session = Depends(get_db)):
+    return crud.ReportFilterViewSet.get_report_filter_types(db, request)
+
+
+@router.post('/get_report_filtered_list', response_model=List[schemas.ReportFilterListSerializer])
+def get_report_filtered_list(request: schemas.ReportFilterInit, db: Session = Depends(get_db)):
+    return crud.ReportFilterViewSet.get_report_filtered_list(db, request)
+
+
+@router.post('/set_report_filter_list', response_model=List[schemas.ReportFilterListSerializer])
+def set_report_filter_list(request: schemas.ReportFilterSetInit, db: Session = Depends(get_db)):
+    return crud.ReportFilterViewSet.set_report_filter_list(db, request)

kv/routers/turnover.py

@@ -0,0 +1,19 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+router = APIRouter()
+
+"""post"""
+
+
+@router.post('/make_storno')
+def make_storno(request: schemas.StronoInit, db: Session = Depends(get_db)):
+    return crud.TurnOverViewSet.make_storno(db, request)
+
+
+@router.post('/get_to_archive')
+def get_to_archive(request: schemas.ArchiveInit, db: Session = Depends(get_db)):
+    return crud.TurnOverViewSet.get_to_archive(db, request)

kv/routers/withdrawing.py

@@ -0,0 +1,33 @@
+import kv.schemas as schemas
+import kv.crud as crud
+from kv.database import get_db
+from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
+from typing import List
+router = APIRouter()
+
+"""get"""
+
+
+@router.get("/get_withdrawing_types", response_model=List[schemas.WithdrawingTypesSerializer])
+def get_withdrawing_types(db: Session = Depends(get_db)):
+    data = crud.WithdrawingViewSet.get_withdrawing_types(db)
+    return data
+
+
+"""post"""
+
+
+@router.post('/set_report_filter_list', response_model=List[schemas.WithdrawingCheckSerializer])
+def set_report_filter_list(request: schemas.WithdrawingCheckInit, db: Session = Depends(get_db)):
+    return crud.WithdrawingViewSet.set_report_filter_list(db, request)
+
+
+@router.post('/get_withdrawing_temp', response_model=List[schemas.WithdrawingTempSerializer])
+def get_withdrawing_temp(request: schemas.WithdrawingTempInit, db: Session = Depends(get_db)):
+    return crud.WithdrawingViewSet.get_withdrawing_temp(db, request)
+
+
+@router.post('/save_withdrawing')
+def save_withdrawing(request: schemas.WithdrawingSave, db: Session = Depends(get_db)):
+    return crud.WithdrawingViewSet.save_withdrawing(db, request)

kv/schemas.py

@@ -0,0 +1,797 @@
+from decimal import Decimal
+from pydantic import BaseModel
+from typing import Optional, List
+from datetime import date, datetime
+
+
+class AddObjectInit(BaseModel):
+    IDCity: int
+    IDStreet: int
+    Number: Optional[str]
+
+
+class AdvancedSearchSerializer(BaseModel):
+    IDPersonalAccount: int
+    IDAddress: int
+    RegionName: Optional[str] = None
+    CityName: Optional[str] = None
+    Address: Optional[str] = None
+    AccountType: Optional[str] = None
+    FullName: Optional[str] = None
+
+
+class SettingsSerializer(BaseModel):
+    CurrentYear: int
+    CurrentMonth: int
+    CurrentMonthName: str
+
+
+class ServiceIDInit(BaseModel):
+    IDService: int
+
+
+class UserInit(BaseModel):
+    IDUser: int = 1
+
+
+class AccountInit(BaseModel):
+    IDAccount: int
+
+
+class CityInit(BaseModel):
+    IDCity: int
+
+
+class AdvancedSearchInit(AccountInit, CityInit):
+    LastName: Optional[str] = None
+    FirstName: Optional[str] = None
+    Patronymic: Optional[str] = None
+
+
+class ReportFilterInit(UserInit):
+    IDFilterType: int
+
+
+class ReportFilterSetInit(ReportFilterInit):
+    IDFilterObject: int
+
+
+class WithdrawingCheckSerializer(BaseModel):
+    IDGetType: int
+
+
+class RentRegisterNoticeInit(BaseModel):
+    IDUser: int = 1
+    IDCashbox: int = 1
+    IsRepayment: bool
+    DateBegin: date
+    DateEnd: date
+
+
+class ObjectMeteringDeviceAddressInit(BaseModel):
+    IDUser: int = 1
+    IDCashbox: int = 1
+    IDObject: int
+    IDAddress: int
+
+
+class DateInit(BaseModel):
+    DateBegin: date
+    DateEnd: date
+
+
+class CashboxInit(UserInit):
+    IDCashbox: int = 1
+
+
+class PAInit(BaseModel):
+    IDPersonalAccount: int
+
+
+class PersonalAccountInit(CashboxInit):
+    IDPersonalAccount: int
+
+
+class GetTypeInit(BaseModel):
+    GetType: bool
+
+
+class PersonalAccountType(PersonalAccountInit, GetTypeInit):
+    pass
+
+
+class PersonalAccount(BaseModel):
+    IDPersonalAccount: int
+
+
+class ObjectInit(BaseModel):
+    IDObject: str
+
+
+class TariffProviderInit(ObjectInit):
+    IDTariffPopulation: int
+
+
+class ObjectMeteringDevicesTypesInit(GetTypeInit, ServiceIDInit, ObjectInit):
+    pass
+
+
+class WithdrawingTempInit(CashboxInit, GetTypeInit):
+    pass
+
+
+class WithdrawingCheckInit(PersonalAccountInit, GetTypeInit, DateInit):
+    pass
+
+
+class WithdrawingSave(PersonalAccountInit, WithdrawingCheckSerializer, DateInit):
+    IDWithdrawingType: int
+    WitdrawingNumber: int
+    IDProviderContract: int
+    IDManagementCompany: int
+
+
+class RepaymentInfoInit(BaseModel):
+    IDCashbox: int
+    IDMoneyType: int
+
+
+class RepaymentInit(RepaymentInfoInit):
+    IDRepaymentType: int
+    RepaymentNumber: int
+    RepaymentDate: date
+
+
+class RecieptCalculateInit(PersonalAccountInit):
+    IDType: int
+    Amount: float
+    AmountFine: float
+
+
+class ReceiptSaveInit(RecieptCalculateInit):
+    IDDebtContract: int
+    IDService: int
+    DateBegin: date
+    DateEnd: date
+    IDMoneyType: int
+    Note: Optional[str] = None
+
+
+class StronoInit(PersonalAccountInit):
+    ReceiptNumber: Optional[str]
+
+
+class ArchiveInit(BaseModel):
+    GetTypeName: Optional[str]
+    GetAdditType: int
+    IDAddress: int
+
+
+class EditTempMeteringDeviceAddressInit(BaseModel):
+    IDUser: int
+    IDCashbox: int
+    IDAddress: int
+    IsChecked: bool
+
+
+class PersonalAccountReportTOFinancialInit(PersonalAccountInit):
+    Month: int
+    vid: int
+    IsAUP: bool
+
+
+class ServicesSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class MeteringDeviceTypeSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class PersonalAccountSerializer(BaseModel):
+    IDAddress: int
+    IDTenants: int
+    IDWorker: Optional[int] = None
+    Address: Optional[str] = None
+    ObjectStreetName: Optional[str] = None
+    ObjectNumber: Optional[str] = None
+    ObjectCorp: Optional[str] = None
+    ObjectType: Optional[str] = None
+    AddressNumber: Optional[str] = None
+    IDAccount: int
+    FullName: Optional[str] = None
+
+
+class PersonalAccountDetailsSerializer(BaseModel):
+    ID: int
+    IDAddress: int
+    IDTenants: int
+    IDWorker: int
+    LastName: Optional[str] = None
+    FirstName: Optional[str] = None
+    Patronymic: Optional[str] = None
+    Note: Optional[str] = None
+    PassportSerialNumber: Optional[str] = None
+    PassportNumber: Optional[str] = None
+    PassportIssueBy: Optional[str] = None
+    PassportIssueDate: Optional[date] = None
+    PassportRegistrationPlace: Optional[str] = None
+    PassportRegistrationDate: Optional[date] = None
+
+
+class AddressesSerializer(BaseModel):
+    IDAddress: int
+    Address: Optional[str] = None
+
+
+class ObjectsSerializer(BaseModel):
+    IDObject: str
+    Address: Optional[str] = None
+    StreetName: Optional[str] = None
+    Number: Optional[str] = None
+    Corp: Optional[str] = None
+
+
+class AddressPersonalAccounts(BaseModel):
+    ID: int
+    IDTenants: int
+    IDWorker: int
+    LastName: Optional[str] = None
+    FirstName: Optional[str] = None
+    Patronymic: Optional[str] = None
+
+
+class EditPersonalAccountAddressInit(BaseModel):
+    IDAddress: int
+    CadastralNumber: Optional[str] = None
+    Privatization: bool
+    Area: float
+    AreaOwned: float
+    AreaAdditional: float
+    AreaAboveNormal: float
+    RoomsNumber: int
+    PeopleNumber: int
+    PeopleWithoutReg: int
+    PeopleAway: int
+    PeopleDependents: int
+    MeteringDeviceHeating: bool
+    MeteringDeviceHotWater: bool
+    MeteringDeviceColdWater: bool
+
+
+class AddressDetailInfoSerializer(BaseModel):
+    IDAddress: int
+    CadastralNumber: Optional[str] = None
+    Privatization: bool
+    Area: float
+    AreaOwned: float
+    AreaAdditional: float
+    AreaAboveNormal: float
+    AreaAboveNormal2: float
+    ODNPersent: float
+    ODN: float
+    ODNArea: float
+    AddressAdditArea: float
+    RoomsNumber: int
+    PeopleNumber: int
+    PeopleWithoutReg: int
+    PeopleAway: int
+    PeopleDependents: int
+    MeteringDeviceHeating: bool
+    MeteringDeviceHotWater: bool
+    MeteringDeviceColdWater: bool
+    IDFias: Optional[str] = None
+    FloorNumber: int
+    FullArea: float
+    ObjectMeteringDeviceHeating: bool
+    ObjectMeteringDeviceEl: bool
+    ObjectMeteringDeviceGas: bool
+    ObjectMeteringDeviceWater: bool
+    ActAvailabilityMeteringDeviceInstallAddressWater: bool
+    ActAvailabilityMeteringDeviceInstallObjectHeating: bool
+    ActAvailabilityMeteringDeviceInstallObjectWater: bool
+    StandartVolumeName: Optional[str] = None
+    MCompanyName: Optional[str] = None
+    BoilerName: Optional[str] = None
+    DirectControl: Optional[str] = None
+    ExecutorName: Optional[str] = None
+
+
+class AddressDetailsSerializer(BaseModel):
+    ID: int
+    IDObject: str
+    IDType: int
+    IDImprovementDegree: int
+    CadastralNumber: Optional[str] = None
+    Number: Optional[str] = None
+    Privatization: bool
+    Area: float
+    AreaOwned: float
+    AreaAboveNormal: float
+    AreaAdditional: float
+    RoomsNumber: int
+    PeopleNumber: int
+    PeopleWithoutReg: int
+    PeopleAway: int
+    PeopleDependents: int
+    Glazing: bool
+    IDSystemHotWater: int
+    IDSystemHotWaterPeriodType: int
+    IDSystemColdWater: int
+    IDSystemColdWaterPeriodType: int
+    IDSystemSewerage: int
+    IDSystemSeweragePeriodType: int
+    IDStandartVolume: int
+    MeteringDeviceHeating: bool
+    MeteringDeviceHotWater: bool
+    MeteringDeviceColdWater: bool
+    ActAvailabilityMeteringDeviceInstallIDType: int
+    ActAvailabilityMeteringDeviceInstallHeating: bool
+    ActAvailabilityMeteringDeviceInstallWater: bool
+
+
+class EditAdressInit(AddressDetailsSerializer):
+    ActionType: Optional[str] = None
+
+
+class TurnOverSerializer(BaseModel):
+    AmountSaldoBegin: float
+    AmountAccrued: float
+    AmountSubsidy: float
+    AmountWithdrawing: float
+    AmountActualAccrued: float
+    AmountReceipt: float
+    AmountSaldoCorrect: float
+    AmountSaldoEnd: float
+    AmountTotalWithFine: float
+
+
+class TOArchiveWithdrawingSerializer(BaseModel):
+    id: int
+    Number: int
+    Name: Optional[str] = None
+    Amount: Optional[str] = None
+
+
+class TOArchiveReceiptSerializer(BaseModel):
+    id: int
+    Number: int
+    PaymentDate: datetime
+    RepaymentDate: datetime
+    DateBegin: date
+    DateEnd: date
+    IDMoneyType: int
+    MoneyTypeName: Optional[str] = None
+    Period: Optional[str] = None
+    Amount: float
+    AmountFine: float
+
+
+class ReportTOFinancialAccount(BaseModel):
+    por: int
+    ServiceName: Optional[str] = None
+    ProviderName: Optional[str] = None
+    DateBegin: date
+    DateEnd: date
+    StandartVolume: float
+    TariffPopulation: float
+    TariffProvider: float
+    AmountSaldoBegin: float
+    AmountTotalAccrued: float
+    AmountAccruedSubsidy: float
+    AmountAccrued: float
+    AmountSubsidy: float
+    AmountWithdrawing: float
+    AmountActualAccrued: float
+    AmountReceipt: float
+    AmountSaldoCorrect: float
+    AmountAccruedPreferential: float
+    AmountSaldoEnd: float
+
+
+class MoneyTypesSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class WorkerTypesSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class PayerCategoryTypesSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class EditObjectServiceInit(BaseModel):
+    ActionType: Optional[str] = None
+    IDObject: str
+    IDService: int
+    IDCity: int
+    IDProviderContractOld: int
+    IDTariffPopulationOld: int
+    IDProviderContract: int
+    IDTariffPopulation: int
+
+
+class TariffsPopulationInit(BaseModel):
+    IDObject: str
+    IDService: int
+    IDCity: int
+    IDProvider: int
+
+
+class PersonalAccountTOServicesSerializer(BaseModel):
+    Rank: int
+    IDPersonalAccount: int
+    IDService: int
+    IDProviderContract: int
+    ServiceName: Optional[str] = None
+    ServiceSecondName: Optional[str] = None
+    ProviderName: Optional[str] = None
+    DateBegin: datetime
+    DateEnd: datetime
+    Spor: int
+    Por: int
+    IDTariffPopulation: int
+    Tariff: float
+    TariffProvider: float
+    StandartVolume: float
+    Volume: float
+    AmountSaldo: float
+    AmountAccrued: float
+    AmountSubsity: float
+    AmountWithdrawing: float
+    AmountActualAccrued: float
+    AmountReceipt: float
+    AmountAccruedSubsidy: float
+    AmountPrin: float
+    AmountFine: float
+
+
+class AddressMeteringDevices(BaseModel):
+    id: int
+    IDMeteringDevice: int
+    IDType: int
+    IDObjectType: int
+    SerialNumber: Optional[str] = None
+    IDAddressAddit: int
+    IDService: int
+    ServiceName: Optional[str] = None
+    MeteringDeviceTypeName: Optional[str] = None
+    VerificationYearInterval: int
+    VerificationDate: date
+    DateEnd: date
+
+
+class ReceiptCalculatedSerializer(BaseModel):
+    IDService: int
+    ServiceName: Optional[str] = None
+    Amount: float
+
+
+class RentRepaymentInfoSerializer(BaseModel):
+    Name: Optional[str] = None
+
+
+class RentRepaymentSerializer(BaseModel):
+    RepaymentNumber: int
+    Type: Optional[str] = None
+    Provider: Optional[str] = None
+    Amount: float
+
+
+class ReportFilterTypeSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class ReportFilterListSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+    IsChecked: bool
+
+
+class ServicesAdditionalSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class RentRegisterNotices(BaseModel):
+    CityName: Optional[str] = None
+    Number: Optional[str] = None
+    Address: Optional[str] = None
+    AccountFullName: Optional[str] = None
+    Amount: float
+    AmountFine: float
+    AmountTotal: float
+
+
+class PersonalAccountDebtSerilizer(BaseModel):
+    ID: int
+    DebtTypeName: Optional[str] = None
+    DecisionNumber: Optional[str] = None
+    DecisionDate: Optional[str] = None
+    DecisionDateEnd: Optional[str] = None
+    FullName: Optional[str] = None
+    ExecutionNumberV: Optional[str] = None
+    DecisionAmountSaldo: float
+    DecisionAmountFine: float
+    DecisionAmountStateDuty: float
+    DecisionAmountReceipt: float
+    DecisionAmountReceiptFine: float
+    AmountReceipt: float
+    AmountReceiptFine: float
+    AmountReceiptStateDuty: float
+
+
+class PersonalAccountDebtsSerializer(BaseModel):
+    ID: int
+    IDType: int
+    IDPersonalAccount: int
+    IDCourt: int
+    Number: Optional[str] = None
+    DateBegin: date
+    DateEnd: date
+    LastName: Optional[str] = None
+    FirstName: Optional[str] = None
+    Patronymic: Optional[str] = None
+    PassportSerialNumber: Optional[str] = None
+    PassportNumber: Optional[str] = None
+    PassportIssueBy: Optional[str] = None
+    PassportIssueDate: date
+    PassportBirthPlace: Optional[str] = None
+    PassportBirthday: date
+    AmountSaldo: float
+    AmountFine: float
+    AmountAccrued: float
+    MonthNumber: int
+    AmountReceipt: float
+    DateOk: date
+    Note: float
+    DateP: date
+    DateIns: date
+    DateUv: date
+    ContractTypeName: Optional[str] = None
+    DateUv: date
+    Decision: bool
+    Execution: bool
+    Amount: float
+    AmountFine: float
+    RepaymentDate: date
+    CourtTypeName: Optional[str] = None
+    CourtNote: Optional[str] = None
+    Contract2Number: Optional[str] = None
+    Contract2DateBegin: date
+
+
+class PersonalAccountsSerializer(BaseModel):
+    ID: int
+
+
+class CommonTypeSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class ProviderTypeSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class ProviderContractSerializer(BaseModel):
+    id: int
+    Name: Optional[str] = None
+    ProviderContractTypeName: Optional[str] = None
+    OrganizationName: Optional[str] = None
+    DateBegin: date
+    DateEnd: date
+
+
+class ManagementCompanySerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class WithdrawingTypesSerializer(BaseModel):
+    ID: int
+    Code: int
+    Name: Optional[str] = None
+
+
+class WithdrawingTempSerializer(BaseModel):
+    id: int
+    IDService: int
+    ServiceName: Optional[str] = None
+    Por: int
+    AmountAccrued: float
+    Amount: float
+
+
+class ObjectDetailsSerializer(BaseModel):
+    IDObject: str
+    IDFias: Optional[str] = None
+    IDBoiler: str
+    IDOwnershipType: int
+    IDProviderUtilityServices: int
+    BuildDate: int
+    FloorNumber: int
+    Entrance: int
+    CommissDate: date
+    Volume: float
+    FullArea: float
+    IDBuildingType: Optional[str] = None
+    IDOverlappingType: int
+    IDWallMaterial: int
+    IDRoofType: int
+    IDFoundationType: int
+    WithdrawingDate: date
+    WithdrawingReason: Optional[str] = None
+    IDSystemHotWater: int
+    IDSystemHotWaterPeriodType: int
+    IDSystemColdWater: int
+    IDSystemColdWaterPeriodType: int
+    IDSystemSewerage: int
+    IDStandartVolume: int
+    IDHeatingType: int
+    IDGasType: int
+    IDWiringType: int
+    IDImprovementDegree: int
+    Amount: float
+    Deterioration: float
+    AreaRoof: float
+    AreaFoundation: float
+    AreaFacade: float
+    AreaPlub: float
+    AreaAttic: float
+    AreaTechnicalFloor: float
+    AreaBuilding: float
+    AreaLk: float
+    AreaYardArea: float
+    AreaBoiler: float
+    ActAvailabilityCounterInstallObjectHeating: int
+    ActAvailabilityCounterInstallObjectWater: int
+    DirectControl: bool
+
+
+class ObjectMunicipalsSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class ObjectServicesSerializer(BaseModel):
+    id: int
+    IDService: int
+    IDProviderContract: int
+    ServiceName: Optional[str] = None
+    por: int
+    ProviderName: Optional[str] = None
+    DateBegin: date
+    DateEnd: date
+    IDTariffPopulation: int
+    TariffPopAmount: float
+    TariffProvAmount: float
+
+
+class ObjectAddressesSerializer(BaseModel):
+    id: int
+    IDObject: str
+    IDAddressType: int
+    AddressTypeName: Optional[str] = None
+    Number: Optional[str] = None
+    FullArea: float
+    OwnedArea: float
+    PeopleNumber: int
+    RoomsNumber: int
+
+
+class MeteringDeviceInit(BaseModel):
+    ActionType: Optional[str] = None
+    IDUser: int
+    ID: int
+    IDService: int
+    IDType: int
+    IDCity: int
+    IDObjectType: int
+    IDObject: str
+    IDAddress: int
+    IDAddressAddit: int
+    IDService: int
+    SerialNumber: Optional[str] = None
+    VerificationDate: date
+    VerificationYearInterval: int
+
+
+class ObjectMeteringDevicesSerializer(BaseModel):
+    ID: int
+    IDService: int
+    IDType: int
+    IDObjectType: int
+    IDAddressAddit: int
+    IDService: int
+    ServiceName: Optional[str] = None
+    MeteringDeviceTypeName: Optional[str] = None
+    SerialNumber: Optional[str] = None
+    VerificationDate: date
+    DateEnd: date
+    AddressDeviceNumber: int
+    VerificationYearInterval: int
+
+
+class ObjectMeteringDeviceAddressesSerializer(BaseModel):
+    IDAddress: int
+    Number: Optional[str] = None
+    IsChecked: bool
+    ix: int
+
+
+class SystemWater(BaseModel):
+    ID: int
+    IDServiceType: int
+    IDPeriodType: int
+    Name: Optional[str] = None
+
+
+class SystemWaterPeriodType(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class OwnershipType(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+
+
+class CommonTypeUUIDSerializer(BaseModel):
+    ID: str
+    Name: Optional[str] = None
+
+
+class ImprovementDegreeSerializer(BaseModel):
+    ID: int
+    Name: Optional[str] = None
+    IDHotWater: Optional[int] = None
+    IDColdWater: Optional[int] = None
+    IDSewerage: Optional[int] = None
+
+
+class ObjectWaterSystemVolumesInit(BaseModel):
+    IDHotWater: int
+    IDColdWater: int
+    IDSewerage: int
+
+
+class TariffPopulationSerializer(BaseModel):
+    ID: int
+    IDService: int
+    IDCity: int
+    Name: Optional[str] = None
+    Amount: float
+
+
+class TariffProviderSerializer(BaseModel):
+    ID: int
+    IDType: int
+    Name: Optional[str] = None
+    ProviderTypeName: Optional[str] = None
+
+
+class ProviderUtilityService(BaseModel):
+    ID: int
+    IDCity: int
+    FullName: str
+    ShortName: Optional[str] = None
+    INN: str
+    KPP: str
+    FIO: Optional[str] = None
+    PhoneNumber: Optional[str] = None
+    ADS: Optional[str] = None
+    Email: Optional[str] = None
+    BankName: Optional[str] = None
+    CheckingAccount: str
+    CorrectAccount: str
+    BIK: str
+    WorkTime: Optional[str] = None

kv/settings

@@ -0,0 +1,12 @@
+{
+    "database": {
+       "engine": "mssql+pyodbc",
+       "name": "Kvartplata",
+       "host": "kts-srv",
+       "user": "sa",
+       "password": "gjghj,eqgjl,thb",
+       "options": {
+          "driver": "SQL Server"
+       }
+    }
+ }