Merge branch 'master' into feature/check_results

# Conflicts: # src/db/mongo_manager.py
2022-07-06 17:42:20 +02:00
parent e9150c885d d495308a1f
commit f4a0b1f439
45 changed files with 160 additions and 109 deletions
@@ -0,0 +1,110 @@
+import datetime
+from typing import Union
+
+import firebase_admin
+from firebase_admin import credentials, firestore
+
+from src import definitions, params
+from src.pojo.MailPojo import MailPojo
+from src.pojo.ReserveResultPojo import ReserveResultPojo
+from src.pojo.ResultEnum import ResultEnum
+from src.pojo.SimInfoPojo import SimInfoPojo
+from src.pojo.contact_pojo import ContactPojo
+
+ERROR_COLLECTION_NAME = "error_items"
+CONTACT_COLLECTION_NAME = "contact_list"
+MAIL_COLLECTION_NAME = "mail_list"
+SIM_INFOS = "sim_infos"
+TIMEOUT = "timeout_items"
+
+
+class DataManager:
+    batch_size = 20
+
+    def __init__(self):
+        cred = credentials.Certificate(definitions.FIREBASE_CONFIG_FILE)
+        self._app = firebase_admin.initialize_app(cred)
+        self._db = firestore.client()
+
+    def get_all_sim_infos(self):
+        params.oracle_log_sender.send_read_db_event("get_all_sim_infos")
+        sim_info_collection = self._db.collection(SIM_INFOS)
+        return sim_info_collection
+
+    def get_all_successful_items(self):
+        params.oracle_log_sender.send_read_db_event("get_all_successful_items")
+        return self.get_all_successful_items_for_day(str(datetime.date.today()), None)
+
+    def get_all_successful_items_for_day(self, day, source_from: Union[str, None]):
+        params.oracle_log_sender.send_read_db_event("get_all_successful_items_for_day for {}".format(day))
+        doc_ref = self._db.collection(day)
+        if source_from is not None:
+            doc_ref.where(u'source_from', u'==', source_from)
+        return doc_ref
+
+    def get_successful_item_for_day_by_status(self, day, status: ResultEnum):
+        params.oracle_log_sender.send_read_db_event("get_successful_item_for_day_by_status for {}".format(day))
+        doc_ref = self._db.collection(day)
+        if status is not None:
+            doc_ref.where(u'accepted', u'==', status.value)
+        return doc_ref
+
+    def save_sim_info(self, sim_info: SimInfoPojo):
+        params.oracle_log_sender.send_read_db_event("save_sim_info")
+        doc_ref = self._db.collection(SIM_INFOS).document(sim_info.phone)
+        doc_ref.set(sim_info.to_firestore_dict())
+
+    def save(self, result: ReserveResultPojo):
+        id = result.url.split("/")[-1]
+        result.id = id
+        collection_name = str(datetime.date.today())
+        doc_ref = self._db.collection(collection_name).document(result.id)
+        doc_ref.set(result.to_firestore_dict())
+        params.mongo_store_manager.insert_reserve_result(collection_name=collection_name, reserve=result)
+
+    def find_appointment_detail_via_phone(self, day, phone) -> ReserveResultPojo:
+        params.oracle_log_sender.send_read_db_event("find_appointment_detail_via_phone")
+        doc_ref = self._db.collection(day)
+        results = doc_ref.where(u'phone', u'==', phone).stream()
+        result_list = []
+        for result in results:
+            result_list.append(ReserveResultPojo.from_firestore_dict(result.to_dict()))
+        if len(result_list) > 0:
+            return result_list[0]
+
+    def save_timeout_contact(self, contact: ContactPojo):
+        doc_ref = self._db.collection(TIMEOUT).document(str(contact.phone))
+        doc_ref.set(contact.to_firestore_dict())
+
+    def _delete_collection(self, coll_ref, batch_size):
+        params.oracle_log_sender.send_read_db_event("_delete_collection")
+        docs = coll_ref.limit(batch_size).stream()
+        deleted = 0
+
+        for doc in docs:
+            print(f'Deleting doc {doc.id} => {doc.to_dict()}')
+            doc.reference.delete()
+            deleted = deleted + 1
+
+        if deleted >= batch_size:
+            return self._delete_collection(coll_ref, batch_size)
+
+    # 删除数据库中所有的sim卡信息
+    def clear_all_sim_info(self):
+        params.oracle_log_sender.send_read_db_event("clear_all_sim_info")
+        coll_ref = self._db.collection(SIM_INFOS)
+        self._delete_collection(coll_ref, self.batch_size)
+
+    def read_contacts_from_db(self) -> list:
+        params.oracle_log_sender.send_read_db_event("read_contacts_from_db")
+        contact_collection = self._db.collection(CONTACT_COLLECTION_NAME)
+        return contact_collection
+
+    def get_mail_list(self) -> list:
+        params.oracle_log_sender.send_read_db_event("get_mail_list")
+        mail_collection = self._db.collection(MAIL_COLLECTION_NAME)
+        mail_list = []
+        for mail in mail_collection.stream():
+            mail_pojo = MailPojo.from_firestore_dict(mail.to_dict())
+            mail_list.append(mail_pojo)
+        return mail_list
@@ -0,0 +1,54 @@
+from builtins import list
+
+import sqlalchemy
+from sqlalchemy import MetaData, Column, String, Integer, DateTime, Table
+from sqlalchemy.orm import Session
+from sqlalchemy_utils import database_exists, create_database
+
+from src.pojo.ReserveResultPojo import ReserveResultPojo
+from src.pojo.captcha_error_contact_pojo import ContactInErrorPojo
+
+
+class LocalDbManager:
+
+    def __init__(self, path: str):
+        self.session = Session(self.init_db(path))
+
+    def init_db(self, path: str):
+        uri_for_db = "sqlite:///{}/{}.db?check_same_thread=false".format(path, "appointment")
+        print(uri_for_db)
+        # 2.-Turn on database engine
+        db_engine = sqlalchemy.create_engine(uri_for_db)  # ensure this is the correct path for the sqlite file.
+        if not database_exists(uri_for_db):
+            create_database(uri_for_db)
+        connextion = db_engine.connect()
+        if not db_engine.dialect.has_table(connextion,
+                                           ContactInErrorPojo.__tablename__):  # If table don't exist, Create.
+            metadata = MetaData(db_engine)
+            # Create a table with the appropriate Columns
+            Table(ContactInErrorPojo.__tablename__, metadata,
+                  Column('id', Integer, primary_key=True, autoincrement=True),
+                  Column('mail', String),
+                  Column('phone', String),
+                  Column('passport', String),
+                  Column('last_name', String),
+                  Column('first_name', String),
+                  Column('ccid', String),
+                  Column('position', Integer),
+                  Column('error_type', Integer),
+                  Column('update_at', DateTime),
+                  Column('create_at', DateTime))
+            # Implement the creation
+            metadata.create_all()
+
+        return db_engine
+
+    def insert_or_update(self, instance: ContactInErrorPojo):
+        self.session.merge(instance)
+        self.session.commit()
+
+    def handle_success(self, reservePojo: ReserveResultPojo):
+        #         delete the contact from table
+        self.session.query(ContactInErrorPojo).filter(ContactInErrorPojo.mail == reservePojo.email).delete()
+
+
@@ -0,0 +1,102 @@
+import datetime
+import logging
+
+from pymongo import MongoClient
+
+from src.pojo.ReserveResultPojo import ReserveResultPojo
+from src.pojo.black_contact import BlackContactPojo
+from src.pojo.contact_pojo import ContactPojo
+
+MONGO_DB_URL = "mongo.lpaconsulting.fr"
+CAPTCHA_ERROR_COLLECTION_PREFIX = "CAPTCHA_ERROR_"
+BLACK_LIST = "BLACK_LIST"
+
+
+class MongoDbManager:
+    def __init__(self):
+        client = MongoClient(MONGO_DB_URL, username='appointment', password='Rdv@2022', authSource='appointment')
+        self.db = client.appointment
+        self.logger = logging.getLogger("mongoDb")
+
+    def insert_one(self, collection_name: str, dict: dict):
+        collection_to_use = self.db[collection_name]
+        collection_to_use.insert_one(dict)
+
+    def insert_reserve_result(self, collection_name, reserve: ReserveResultPojo):
+        try:
+            collection_to_use = self.db[collection_name]
+            collection_to_use.replace_one(filter={'_id': reserve.id, }, replacement=reserve.to_firestore_dict(),
+                                          upsert=True)
+        except Exception as Error:
+            self.logger.info(Error)
+
+    def insert_captcha_error_contact(self, contact: ContactPojo):
+        day = str(datetime.date.today())
+        collection_name = CAPTCHA_ERROR_COLLECTION_PREFIX + day
+        try:
+            collection_to_use = self.db[collection_name]
+            collection_to_use.replace_one(filter={'_id': contact.mail, }, replacement=contact.to_firestore_dict(),
+                                          upsert=True)
+        except Exception as error:
+            self.logger.info(error)
+
+    def insert_blacklist_contact(self, contact: ContactPojo):
+        collection_name = BLACK_LIST
+        black_contact = BlackContactPojo(contact.phone, contact.passport, contact.last_name, contact.first_name,
+                                         contact.mail)
+        try:
+            collection_to_use = self.db[collection_name]
+            collection_to_use.replace_one(filter={'_id': black_contact.mail, },
+                                          replacement=black_contact.to_firestore_dict(),
+                                          upsert=True)
+        except Exception as error:
+            self.logger.info(error)
+
+    def get_all_successful_items_for_day(self) -> list:
+        params.oracle_log_sender.send_read_db_event("get_all_successful_items_for_day")
+        collection_name = str(datetime.date.today())
+        result_list = []
+        cursor = self.db[collection_name]
+        for document in cursor.find():
+            result_list.append(ReserveResultPojo.from_firestore_dict(document))
+        return result_list
+
+    def get_all_successful_items_for_one_day(self, day_in_str: str) -> list:
+        params.oracle_log_sender.send_read_db_event("get_all_successful_items_for_one_day")
+        collection_name = day_in_str
+        result_list = []
+        cursor = self.db[collection_name]
+        for document in cursor.find():
+            result_list.append(ReserveResultPojo.from_firestore_dict(document))
+        return result_list
+
+    def update_reserve_result(self, reserve_id: str, result: ResultEnum):
+        collection_name = str(datetime.date.today())
+        collection = self.db[collection_name]
+        collection.find_one_and_update({'_id': reserve_id}, {"$set": {"accepted": result.name}}, upsert=False)
+
+    def get_captcha_error_contacts_for_current_day(self) -> list:
+        day = str(datetime.date.today())
+        collection_name = CAPTCHA_ERROR_COLLECTION_PREFIX + day
+        cursor = self.db[collection_name]
+        contact_list = []
+        for document in cursor.find():
+            contact_list.append(ContactPojo.from_firestore_dict(document))
+        return contact_list
+
+    def delete_captcha_error_contact_for_current_day(self, contact: ContactPojo):
+        day = str(datetime.date.today())
+        collection_name = CAPTCHA_ERROR_COLLECTION_PREFIX + day
+        collection = self.db[collection_name]
+        to_delete = {'_id': contact.mail}
+        try:
+            collection.delete_one(to_delete)
+        except Exception as error:
+            self.logger.info(error)
+
+
+if __name__ == '__main__':
+    db_manager = MongoDbManager()
+    contact = ContactPojo(phone_number='0755667750', passport_number='123456789', last_name='PAN', first_name='Lei',
+                          mail='panleicim@gmail.com')
+    print(db_manager.insert_blacklist_contact(contact))