can export accepted infos

db/mongo_manager.py

@@ -8,6 +8,7 @@ from models.LinkPojo import LinkPojo
 from models.ReserveResultPojo import ReserveResultPojo
 from models.contact_pojo import ContactPojo
 from models.mail_pojo import MailAddress
+from models.regisered_user_pojo import RegisteredUserPojo
 
 MONGO_DB_URL = "mongo.lpaconsulting.fr"
 CAPTCHA_ERROR_COLLECTION_PREFIX = "CAPTCHA_ERROR_"
@@ -98,6 +99,27 @@ class MongoDbManager:
             },
                                           upsert=True)
 
+    def get_code_for_email(self, email: str):
+        collection_name = DESTINATION_EMAIL_LIST
+        try:
+            collection_to_use = self.db[collection_name]
+            mailDocument = collection_to_use.find_one(filter={'_id': email})
+            if mailDocument is not None:
+                return MailAddress.from_firestore_dict(mailDocument).password
+            else:
+                return ""
+        except Exception as error:
+            self.logger.info(error)
+            return ""
+
+    def get_all_registered_users(self) -> list:
+        _collection_name = "Registered_users"
+        _cursor = self.db[_collection_name]
+        registered_user_list = []
+        for document in _cursor.find():
+            registered_user_list.append(RegisteredUserPojo.from_firestore_dict(document))
+        return registered_user_list
+
     def get_destination_emails(self) -> list:
         collection_name = DESTINATION_EMAIL_LIST
         email_list = []

models/AcceptedResultPojo.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+
+from dataclasses_json import dataclass_json
+
+from db.mongo_manager import MongoDbManager
+from models import ReserveResultPojo
+
+
+@dataclass_json
+@dataclass
+class AcceptedResultPojo:
+
+    def __init__(self, msg: str, slot_position, sim_position, passport, email, name, phone, ccid: str, url,
+                 created_at: str, validated_at: str):
+        self.message = msg
+        self.slot_position = slot_position
+        self.sim_position = sim_position
+        self.passport = "{}".format(passport)
+        self.email = email
+        self.name = name
+        self.phone = phone
+        self.ccid = ccid
+        self.url = url
+        self.created_at = created_at
+        self.validated_at = validated_at
+        self.mail_password = ""
+        self.account_password = ""
+        self.store = ""
+        self.time = ""
+
+    def __repr__(self):
+        return str(self.__dict__)
+
+
+def get_accepted_result_from(reserve_pojo: ReserveResultPojo, mongo_db_manager: MongoDbManager,
+                             all_contact_list) -> AcceptedResultPojo:
+    if reserve_pojo.lastName is None or len(reserve_pojo.lastName) == 0:
+        for _contact in all_contact_list:
+            if _contact.mail == reserve_pojo.mail:
+                reserve_pojo.lastName = _contact.last_name
+                reserve_pojo.firstName = _contact.first_name
+                reserve_pojo.phone = _contact.phone
+                reserve_pojo.passport = _contact.passport
+
+    if reserve_pojo is None:
+        #     send email even there are no reserve info
+        return AcceptedResultPojo("", slot_position=0, sim_position=0,
+                                  passport="", email="", phone="",
+                                  name="", ccid="",
+                                  url="", created_at="", validated_at="")
+    else:
+        toReturn = AcceptedResultPojo(reserve_pojo.message, slot_position=reserve_pojo.slot_position,
+                                      sim_position=reserve_pojo.sim_position,
+                                      passport=reserve_pojo.passport, email=reserve_pojo.email,
+                                      phone=reserve_pojo.phone,
+                                      name="{} {}".format(reserve_pojo.lastName, reserve_pojo.firstName),
+                                      ccid=reserve_pojo.ccid,
+                                      url=reserve_pojo.url, created_at=reserve_pojo.created_at,
+                                      validated_at=reserve_pojo.validated_at)
+        toReturn.mail_password = mongo_db_manager.get_code_for_email(reserve_pojo.email)
+        return toReturn

models/regisered_user_pojo.py

@@ -0,0 +1,54 @@
+class RegisteredUserPojo:
+    phone: str
+    city: str
+    last_name: str
+    first_name: str
+    mail: str
+    address: str
+    zip_code: str
+    password: str = None
+
+    def __init__(self, phone_number: str, last_name: str, first_name: str, mail: str,
+                 address: str = "",
+                 zip_code: str = None, city: str = None):
+        self.phone = "0" + str(int(phone_number))
+        self.city = city
+        self.last_name = last_name
+        self.first_name = first_name
+        self.address = address
+        self.mail = mail
+        self.zip_code = zip_code
+
+    def __repr__(self):
+        return "last_name:{}, first_name:{}, email:{}, password:{}".format(self.last_name, self.first_name, self.mail,
+                                                                           self.password)
+
+    def to_firestore_dict(self):
+        dest = {
+            u'phone': self.phone,
+            u'city': self.city,
+            u'last_name': self.last_name,
+            u'first_name': self.first_name,
+            u'mail': self.mail,
+            u'address': self.address,
+            u'zip_code': self.zip_code,
+            u'password': self.password
+        }
+
+        return dest
+
+    @staticmethod
+    def from_firestore_dict(source):
+        address = source['address']
+        phone = source['phone']
+        zip_code = source['zip_code']
+        city = source['city']
+        email = source['mail']
+        last_name = source['last_name']
+        first_name = source['first_name']
+        result = RegisteredUserPojo(address=address, phone_number=phone, city=city, zip_code=zip_code,
+                                    mail=email,
+                                    last_name=last_name, first_name=first_name)
+        if 'password' in source:
+            result.password = source['password']
+        return result

workers/find_infos_from_results.py

@@ -0,0 +1,72 @@
+import glob
+import re
+
+from db.mongo_manager import MONGO_STORE_MANAGER
+from models import AcceptedResultPojo
+
+CONFIRMATION_SENTENCE = "Nous avons le plaisir de vous confirmer votre rendez-vous"
+TIME_REGEX = "([0-1]?[0-9]|2[0-3]):[0-5][0-9]"
+
+
+def get_store_info_from_html_content(_content):
+    store = ""
+    if "Faubourg" in _content:
+        print("found")
+        store = "Faubourg"
+    elif "George V" in _content:
+        store = "George V"
+    elif "Sèvres" in _content:
+        store = "BM"
+    time_results = re.search(TIME_REGEX, _content)
+    time = time_results[0]
+    return store, time
+
+
+def find_ids_from_results():
+    _html_files = glob.glob("results/*.html")
+    info_list = []
+    for _file in _html_files:
+        f = open(_file, "r")
+        _content = f.read()
+        if CONFIRMATION_SENTENCE in _content:
+            appointment_info = get_store_info_from_html_content(_content)
+            _id = _file.split("_")[-1].split(".")[0]
+            info_list.append((_id, appointment_info))
+    return info_list
+
+
+# info_list (id, (store, time))
+def get_appointment_info_from_id(info_list: list):
+    _all_items = MONGO_STORE_MANAGER.get_all_successful_items_for_yesterday()
+    _all_contact_list = MONGO_STORE_MANAGER.get_all_contact_to_book_list()
+    _all_register_account = MONGO_STORE_MANAGER.get_all_registered_users()
+    accepted_appointments = []
+    for _item in _all_items:
+        for _info in info_list:
+            if _item.id == _info[0]:
+                _accepted = AcceptedResultPojo.get_accepted_result_from(_item, MONGO_STORE_MANAGER, _all_contact_list)
+                _accepted.store = _info[1][0]
+                _accepted.time = _info[1][1]
+                accepted_appointments.append(_accepted)
+    for _accepted in accepted_appointments:
+        for user in _all_register_account:
+            if user.mail == _accepted.email:
+                _accepted.account_password = user.password
+    return accepted_appointments
+
+
+if __name__ == '__main__':
+    accepted_appointments = get_appointment_info_from_id(find_ids_from_results())
+    for _accepted in accepted_appointments:
+        print("""
+        姓名：{} ({} {})
+        电话：{} ,邮箱：{}，
+        邮箱密码：{}
+        护照: {},
+        约会url:{},
+        账户密码：{}""".format(_accepted.name, _accepted.store,
+                              _accepted.time,
+                              _accepted.phone, _accepted.email,
+                              _accepted.mail_password,
+                              _accepted.passport, _accepted.url
+                              , _accepted.account_password))

workers/result_link_checker.py

@@ -156,7 +156,7 @@ class ResultLinkChecker(threading.Thread):
 
 
 def start_check_links(_queue_name, link_list, logger):
-    _proxy_manager = ProxyManager()
+    _proxy_manager = ProxyManager(logger)
     cookiesPublisher = CookiesPublisher(queue_name=REQUEST_DATA_QUEUE_TEST)
     cookiesPublisher.set_up_connection()
     receiver = ResultLinkChecker(cookiesPublisher=cookiesPublisher, proxy_manager=_proxy_manager, all_links=link_list,
@@ -176,7 +176,7 @@ def check_all_links(_segment_number=2):
             _link_list.append(_item.url)
     print(_link_list)
     # _link_list_filted = _link_list[4000:-1]
-    _link_list_filted = _link_list
+    _link_list_filted = _link_list[-4:-1]
     thread_list = []
     for i in range(0, _segment_number):
         logger.info("segment is {}".format(i))
@@ -192,4 +192,4 @@ def check_all_links(_segment_number=2):
 
 
 if __name__ == '__main__':
-    check_all_links()
+    check_all_links(_segment_number=2)