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

Atol_check.bat

@@ -0,0 +1,2 @@
+CD %CD%
+py -3.9 check_start.py

Atol_token.bat

@@ -0,0 +1 @@
+py -3.9 C:\projects\service-app\kassa\atol_token.py

infosys/ismain.py

@@ -0,0 +1,11 @@
+from infosys.routers import general
+from fastapi import APIRouter, Depends
+from auth import oauth2
+from auth.login.schemas import login as schemas
+
+router = APIRouter()
+router.include_router(
+    router=general.router,
+    prefix="",
+    responses={404: {"description": "info is not found"}}
+)

kassa/atol.py

@@ -22,7 +22,7 @@ class Atol:
 
     def get_request(self, method, url, data):
         if method == "post":
-            r = requests.post(self.url+url, data=json.dumps(data),
+            r = requests.post(self.url+url, data=json.dumps(data), 
                               headers=self.get_headers())
         else:
             r = requests.get(self.url+url, headers=self.get_headers())

kassa/atol_token.py

@@ -0,0 +1,12 @@
+from sber_db import engine
+from atol import Atol
+from datetime import datetime
+import pandas as pd
+
+
+if __name__ == "__main__":
+    token = Atol('').get_token(login='jkhsakha-ru', password='OQ7vuDaIP')
+    print(token)
+    cur_date = datetime.now()
+    df = pd.DataFrame([{'date_create': cur_date, 'token': token}])
+    df.to_sql('atol_tokens', con=engine, if_exists='append', index=False)

kassa/cruds/doc.py

@@ -26,14 +26,13 @@ def create_doc(db: Session, doc: schemas.Doc, external_id: str = None):
 
 def create_error(db: Session, error: schemas.Error, external_id: str = None):
     err = error
-    
-    err['external_id'] = external_id
     err_query = db.query(models.Error).filter(
         models.Error.external_id == external_id)
     if err_query.first():
 
         err_query.update(values=err)
     else:
+        err['external_id'] = external_id
         err_query = models.Error(**err)
         db.add(err_query)
     db.commit()

kassa/kassa.py

@@ -1,13 +1,13 @@
 from fastapi import APIRouter, Depends
-import kassa.databases as databases
+import kassa.database as database
 import kassa.cruds.doc as doc
 import kassa.schemas as schemas
 import kassa.models as models
 
-models.Base.metadata.create_all(databases.engine)
+models.Base.metadata.create_all(database.engine)
 router = APIRouter()
 
-get_db = databases.get_db
+get_db = database.get_db
 
 
 @router.post('/{external_id}')

kassa/models.py

@@ -1,7 +1,7 @@
 from sqlalchemy.sql.schema import ForeignKey
 from sqlalchemy import Column, Integer, String, Numeric, DateTime, Boolean, BigInteger
 from sqlalchemy.orm import relationship
-from kassa.databases import Base
+from kassa.database import Base
 
 
 class Payment(Base):
@@ -37,8 +37,8 @@ class Doc(Base):
     uuid = Column('uuid', String(length=128), primary_key=True)
     timestamp = Column('timestamp', String(length=128))
     group_code = Column('group_code', String(length=128))
-    daemon_code = Column('daemon_code', String(length=128))
+    daemon_code = Column('daemon_code', String(length=128), nullable= True)
-    device_code = Column('device_code', String(length=128))
+    device_code = Column('device_code', String(length=128), nullable= True)
     external_id = Column('external_id', String(length=128))
     callback_url = Column('callback_url', String(length=128))
     status = Column('status', String(length=128))

kassa/new.py

@@ -1,6 +1,4 @@
-from ast import While
+from calendar import month
-from lib2to3.pgen2 import token
-from re import A
 from time import sleep
 from typing import Dict, List, Tuple
 from sqlalchemy.ext.declarative import declarative_base
@@ -13,7 +11,7 @@ from sqlalchemy import desc, cast, case, func
 import kassa.schemas as schemas
 import kassa.models as models
 from kassa.cruds import doc
-from kassa.databases import SessionLocal
+from kassa.database import SessionLocal
 from kassa.atol import Atol
 import datetime
 
@@ -72,10 +70,10 @@ class DBEngine:
 
 def get_payment_details(db: Session, engine_class: DBEngine):
     pd = engine_class.get_table('payment_details')
-    external_id, is_refund, is_taken = engine_class.get_columns(
+    year, month, external_id, is_refund, is_taken = engine_class.get_columns(
-        'payment_details', ['external_id', 'is_refund', 'is_taken'])
+        'payment_details', ['year','month','external_id', 'is_refund', 'is_taken'])
-    query = db.query(pd).filter(is_taken == 0).with_entities(
+    query = db.query(pd).filter(is_taken == False).with_entities(
-        external_id, is_refund, is_taken).distinct().order_by(external_id, desc(is_refund))
+        external_id, is_refund, is_taken).distinct().order_by(year, month,external_id, desc(is_refund))
     return query
 
 
@@ -111,7 +109,7 @@ def get_payment(db: Session, engine_class: DBEngine, payment_details: Tuple):
 def get_payment_details_items(db: Session, engine_class: DBEngine, dict_engine: DBEngine, payment_details: Tuple):
     payment = get_payment(
         db, engine_class, payment_details).subquery('payment')
-    services = dict_engine.get_table('services')
+    services = dict_engine.get_table('vServices')
     units = dict_engine.get_table('units')
     payment_method = dict_engine.get_table('payment_method')
     payment_object = dict_engine.get_table('payment_object')
@@ -148,7 +146,7 @@ def get_payment_details_items(db: Session, engine_class: DBEngine, dict_engine:
         .join(payment_object, payment.c.payment_object == payment_object.c["id"])\
         .join(vats, payment.c.vat == vats.c["id"])\
         .join(company, payment.c.id_company == company.c["id_provider"])\
-        .join(agents, payment.c.supplier_info == agents.c["id_agent"])
+        .join(agents, payment.c.supplier_info == agents.c["id_agent"], isouter=True)
     return query
 
 
@@ -163,15 +161,14 @@ def get_payments(data: List):
         type_id = row.get("payment_group")
         cur_sum = row.get("sum")
         d[type_id] = cur_sum + d.get(type_id, 0.0)
-    res = [{'type': i[0], 'sum': i[1]} for i in d.items()]
+    res = [{'type': i[0], 'sum': round(i[1],2)} for i in d.items()]
     return res
 
 
 def get_token(db: Session, db_dict: DBEngine):
     token_dict = db_dict.get_table("vAtolToken")
-    rows = db.query(token_dict).first()
+    rows = db.query(token_dict.c["token"].label("token")).select_from(token_dict)
-    return dict(rows).get("token")
+    return dict(rows.first()).get("token")
-
 
 """
 #Функция для заполнения total
@@ -219,10 +216,10 @@ def items_convert(data: query):
             for i in ["supplier_info", 'supplier_inn', 'supplier_name']:
                 del item[i]
         items.append(item)
-    payments = [{'type': i[0], 'sum': i[1]} for i in d.items()]
+    payments = [{'type': i[0], 'sum': round(i[1],2)} for i in d.items()]
     client = get_client(phone)
     company = get_company(inn)
-    return external_id, items,  payments, client, company, total
+    return external_id, items,  payments, client, company, round(total,2)
 
 
 def get_company(inn: int):
@@ -243,7 +240,7 @@ def get_receipt(data: query):
     receipt["payments"] = payments
     receipt["company"] = company
     receipt['items'] = items
-    receipt['total'] = total
+    receipt['total'] = round(total,2)
     return external_id, receipt
 
 
@@ -314,18 +311,14 @@ def add_doc(sell: schemas.Sell, is_refund, token):
 def get_check(db: Session, uuid: str, external_id: str, token: str):
     atol_model = Atol(token)
     a = atol_model.get_reciepts(uuid)
-    err = a.pop('error', None)
+    doc.create_doc(db, schemas.Doc(**a), external_id)
-    if err:
-        print(err)
-        return doc.create_error(db, error = schemas.Error(**err), external_id = external_id )
-    doc.create_doc(db, a, external_id)
     return a
 
 
 def get_atol_wo_doc(db: Session):
+    doc_sq = db.query(func.upper(models.Doc.external_id)).subquery()
     return db.query(models.Atol.uuid, models.Atol.external_id).\
-        where(models.Atol.external_id.notin_(models.Doc.external_id)).\
+        filter(func.upper(models.Atol.external_id).notin_(doc_sq))
-        all()
 
 def get_main_payment():
     server = 'Sanctuary'
@@ -336,12 +329,14 @@ def get_main_payment():
     db = DBEngine(server, dbname, user, password)
     db_dicts = DBEngine(server, db_dicts_name, user, password)
     session = Session(autocommit=False, autoflush=False, bind=db.engine)
-    payment = get_payment_details(session, db).first()
+    payment_query = get_payment_details(session, db)
+    payment = payment_query.first()
     if payment:
         payments = get_payment_details_items(session, db, db_dicts, payment)
         body = get_sell(payments)
-        sell = schemas.Sell(**body)
         payment = dict(payment)
+        print(payment.get("external_id"))
+        sell = schemas.Sell(**body)
         atol = {
             "external_id": payment.get("external_id"),
             "is_refund": payment.get("is_refund"),
@@ -359,21 +354,32 @@ def main():
         payment, is_refund, token = get_main_payment()
         if payment == False:
             break
-        sleep(1)
+        sleep(8)
         doc = add_doc(sell=payment, is_refund=is_refund, token = token)
         print(doc)
         
-def run_get_check():
+
+
+def get_actual_token():
+    server = 'Sanctuary'
+    user = 'sa'
+    password = '159357'
+    dbname = 'fz54_details'
+    db_dicts_name = 'fz54'
+    db = DBEngine(server, dbname, user, password)
+    db_dicts = DBEngine(server, db_dicts_name, user, password)
+    session = Session(autocommit=False, autoflush=False, bind=db.engine)
+    token  = get_token(session, db_dicts)  
+    return token
+
+
+def run_get_check():   
     session = SessionLocal()
-    atols = get_atol_wo_doc(session)
+    print(get_atol_wo_doc(session))
+    atols = get_atol_wo_doc(session).all() 
     while len(atols)>0:
-        server = 'Sanctuary'
+        sleep(0.2)
-        user = 'sa'
-        password = '159357'
-        db_dicts_name = 'fz54'
-        db = Session(autocommit=False, autoflush=False, bind=db.engine)
-        db_dicts = DBEngine(server, db_dicts_name, user, password)
-        token = get_token(db, db_dicts)
         uuid, ext_id = atols.pop()
+        token = get_actual_token()
         check = get_check(session, uuid, ext_id, token)
         print(check)

kassa/sber_db.py

@@ -0,0 +1,23 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+
+
+SQL_ALCHEMY_DATABASE_URL_MSSQL = "mssql+pyodbc://sa:gjghj,eqgjl,thb@172.16.4.58:1433/acquiring_sber?driver=SQL+Server"
+
+
+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_db():
+    db = SessionLocal()
+    try:
+        yield db
+    finally:
+        db.close()

kassa/schemas.py

@@ -6,11 +6,11 @@ from sqlalchemy.sql.sqltypes import DateTime
 
 
 class SumNumberTwoFormat(BaseModel):
-    __root__: Optional[confloat(ge=0.0, le=100000000.0, multiple_of=0.01)]
+    __root__: Optional[confloat(ge=0.0, le=100000000.0)]#, multiple_of=0.01)]
 
 
 class NumberPrice(BaseModel):
-    __root__: confloat(ge=0.0, le=42949673.0, multiple_of=0.01)
+    __root__: confloat(ge=0.0, le=42949673.0)#, multiple_of=0.01)
 
 
 class PhoneNumber(BaseModel):
@@ -18,7 +18,7 @@ class PhoneNumber(BaseModel):
 
 
 class NumberTwoFormat(BaseModel):
-    __root__: confloat(ge=0.0, le=100000000.0, multiple_of=0.01)
+    __root__: confloat(ge=0.0, le=100000000.0)#, multiple_of=0.01)
 
 
 class NumberThreeFormat(BaseModel):
@@ -182,11 +182,11 @@ class Correction(BaseModel):
 
 
 class Doc(BaseModel):
-    uuid: str
+    uuid: Optional[str] = None
     timestamp: str
-    group_code: str
+    group_code:Optional[str] = None
-    daemon_code: str
+    daemon_code: Optional[str] = None
-    device_code: str
+    device_code: Optional[str] = None
     external_id: Optional[str] = None
     callback_url: Optional[str] = None
     status: Optional[str] = None

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/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/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"
+       }
+    }
+ }

main.py

@@ -1,9 +1,11 @@
 from fastapi import FastAPI, Depends, HTTPException, status
 from fastapi.middleware import Middleware
 from fastapi.middleware.cors import CORSMiddleware
+
 from kv import kv
 from auth import auth
 from kassa import kassa
+from infosys import ismain
 import uvicorn
 
 middleware = [Middleware(
@@ -14,7 +16,7 @@ middleware = [Middleware(
     allow_headers=['*'],
 )]
 
-app = FastAPI(middleware=middleware)
+app = FastAPI( middleware=middleware)
 
 
 @app.get('/hello')
@@ -27,12 +29,21 @@ app.include_router(
     tags=['Авторизация'],
     responses={404: {"description": "Not found"}}
 )
+
 app.include_router(
     router=kv.router,
     prefix='/kv',
     tags=['Кварплата'],
     responses={404: {"description": "Not found"}}
 )
+
+
+app.include_router(
+    router=ismain.router,
+    prefix='/is',
+    tags=['Информационная система'],
+    responses={404: {"description": "Not found"}}
+)
 app.include_router(
     router=kassa.router,
     prefix='/kassa',
@@ -41,4 +52,4 @@ app.include_router(
 )
 
 if __name__ == "__main__":
-    uvicorn.run("main:app", host="0.0.0.0", port=4321)
+    uvicorn.run("main:app", host="0.0.0.0", port=4321, reload = True)

settings

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

Новый текстовый документ.txt

@@ -1,2 +1 @@
-CD %CD%
+py -3.9 C:\\projects\service-app\kassa\atol_token.py
-py -3.9 main.py