Last worked version

app.py

@@ -0,0 +1,167 @@
+from sqlalchemy.orm import sessionmaker
+from dbmodels import DBEngine, FZ54, metadata, FZ54Details, Sell, PayloadTable, ErrorTable, DocTable, AtolTable
+from atol import Atol
+from basemodels import Error, SellBaseModel, DocModel
+from time import sleep
+from datetime import datetime
+import json
+
+
+def db_init():
+    server = '172.27.31.195:1433'
+    user = 'sa'
+    password = '159357'
+    dbname = 'fz54'
+    db = DBEngine(server, dbname, user, password)
+    dbname = 'fz54_details'
+    dbinfo = DBEngine(server, dbname, user, password)
+    return db, dbinfo
+
+
+def main():
+    db_fz, db_fzdetails = db_init()
+    models = FZ54(db_fz)
+    metadata.create_all(db_fz.engine)
+    details = FZ54Details(db_fzdetails)
+    return models, details
+
+
+def sell(fz, fzd):
+    res = Sell(fz, fzd)
+    dicts = res.make()
+    return dicts
+
+
+def clear_dict(d):
+    if d is None:
+        return None
+    elif isinstance(d, list):
+        return list(filter(lambda x: x is not None, map(clear_dict, d)))
+    elif not isinstance(d, dict):
+        return d
+    else:
+        r = dict(
+            filter(lambda x: x[1] is not None,
+                   map(lambda x: (x[0], clear_dict(x[1])),
+                       d.items())))
+        if not bool(r):
+            return None
+        return r
+
+
+def connection_db(models):
+    Session = sessionmaker(autocommit=False, bind=models.db.engine)
+    return Session()
+
+
+def sell_items(sell_base_models, models, token):
+    for sell_base_model in sell_base_models:
+        sbm = clear_dict(sell_base_model.dict())
+        ext_id = sbm.get('external_id')
+        session1 = Atol(token)
+        sss = connection_db(models)
+        try:
+            sell = session1.set_sell(sbm)
+            sell['external_id'] = ext_id
+            err_sell = sell.pop('error')
+            doc_model = clear_dict(sell)
+            try:
+                atol = AtolTable(**doc_model)
+                sss.add(atol)
+                sss.commit()
+            except Exception as e:
+                sss.rollback()
+        except Exception:
+            error = err_sell
+            error['external_id'] = ext_id
+            err = ErrorTable(**error)
+            zz = connection_db(models)
+            try:
+                zz.add(err)
+                zz.commit()
+            except Exception as e:
+                zz.rollback()
+            finally:
+                zz.close()
+        finally:
+            sss.close()
+        sleep(2)
+
+
+def get_receipt(uuid, ext_id, models, atol_session):
+    sell = atol_session.get_reciepts(uuid)
+    session = connection_db(models)
+    try:
+
+        doc_dict = DocModel(**sell)
+        doc_model = doc_dict.dict()
+        error = doc_model.pop('error')
+        payload = doc_model.pop('payload')
+        if type(error) is dict:
+            try:
+                error['external_id'] = ext_id
+                err = ErrorTable(**error)
+            except Exception as e:
+                print(e)
+        if type(payload) is dict:
+            try:
+                payload['external_id'] = ext_id
+                pay = PayloadTable(**payload)
+            except Exception as e:
+                print(e)
+        doc = DocTable(**doc_model)
+        if type(payload) is dict:
+            session.add(doc)
+            session.add(pay)
+            session.commit()
+        elif type(error) is dict:
+            session.add(doc)
+            session.add(err)
+            session.commit()
+        print(doc_dict)
+    except Exception as e:
+        print(e)
+        print(doc_dict)
+        error = sell.get('error')
+        error['external_id'] = ext_id
+        err = ErrorTable(**error)
+        ss = session
+        try:
+            ss.add(err)
+            ss.commit()
+        except Exception as e:
+            print(e)
+            ss.rollback()
+    finally:
+        session.close()
+
+
+def remove_tuple(lst):
+    return [item[0] for item in lst]
+
+
+if __name__ == "__main__":
+    starttime = datetime.now()
+    models, details = main()
+    token = models.get_token()
+    sell_models = sell(models, details)
+    sell_base_models = SellBaseModel().parse(db_dict_list=sell_models)
+    inst_list_query = 'SELECT external_id FROM sell WHERE external_id NOT IN(\
+                        SELECT external_id FROM atol_receipt )\
+                        ORDER BY [timestamp]'
+    inst_list = connection_db(models).execute(inst_list_query).fetchall()
+    sell_base_models = [model for model in sell_base_models if model.dict().get(
+        'external_id') in remove_tuple(inst_list)]
+    sell_items(sell_base_models, models, token.get('token'))
+    endfirsttime = datetime.now()
+    deltatime = starttime - endfirsttime
+    print(f'прошло {deltatime.seconds}')
+    receipt_list = connection_db(models).execute(
+        "SELECT external_id, uuid FROM atol_receipt WHERE external_id not in (select external_id FROM docs)")
+    for rec in list(receipt_list):
+        sleep(2)
+        ext_id, uuid = rec
+        get_receipt(uuid, ext_id, models, Atol(token.get('token')))
+    donetime = datetime.now()
+    deltaendtime = starttime - donetime
+    print(f'прошло {deltaendtime.seconds}')