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

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))
-    device_code = Column('device_code', String(length=128))
+    daemon_code = Column('daemon_code', String(length=128), nullable= True)
+    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 lib2to3.pgen2 import token
-from re import A
+from calendar import month
 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(
-        'payment_details', ['external_id', 'is_refund', 'is_taken'])
-    query = db.query(pd).filter(is_taken == 0).with_entities(
-        external_id, is_refund, is_taken).distinct().order_by(external_id, desc(is_refund))
+    year, month, external_id, is_refund, is_taken = engine_class.get_columns(
+        'payment_details', ['year','month','external_id', 'is_refund', 'is_taken'])
+    query = db.query(pd).filter(is_taken == False).with_entities(
+        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()
-    return dict(rows).get("token")
-
+    rows = db.query(token_dict.c["token"].label("token")).select_from(token_dict)
+    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)
-    if err:
-        print(err)
-        return doc.create_error(db, error = schemas.Error(**err), external_id = external_id )
-    doc.create_doc(db, a, external_id)
+    doc.create_doc(db, schemas.Doc(**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)).\
-        all()
+        filter(func.upper(models.Atol.external_id).notin_(doc_sq))
 
 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'
-        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)
+        sleep(0.2)
         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
-    daemon_code: str
-    device_code: str
+    group_code:Optional[str] = None
+    daemon_code: Optional[str] = None
+    device_code: Optional[str] = None
     external_id: Optional[str] = None
     callback_url: Optional[str] = None
     status: Optional[str] = None