buff1.0/buff/sendMail/main.py

import os
import sys

from PyQt5.QtWidgets import QMessageBox
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout, QHBoxLayout, QWidgetItem
from PyQt5.QtCore import Qt, QMetaObject, Q_ARG
import sqlite3
import threading
import time
from datetime import datetime, timedelta
from extract_and_save import run
import logging
from logging.handlers import TimedRotatingFileHandler

# 创建文件夹【日志log】
if not os.path.exists('日志log'):
    os.makedirs('日志log')

# class CustomTimedRotatingFileHandler(TimedRotatingFileHandler):
#     def doRollover(self):
#         # 获取当前时间
#         current_time = datetime.now() - timedelta(days=1)
#         # 获取当前日期
#         current_date = current_time.strftime('%Y-%m-%d')
#         # 获取当前日志文件名
#         base_filename = os.path.splitext(self.baseFilename)[0]
#         extension = os.path.splitext(self.baseFilename)[1]
#         # 构建新的日志文件名
#         new_filename = f"{base_filename}_{current_date}{extension}"
#         # 如果当前日志文件存在，则重命名
#         if os.path.exists(self.baseFilename):
#             # 添加一个短暂的延迟
#             # time.sleep(1)
#             try:
#                 os.rename(self.baseFilename, new_filename)
#             except PermissionError as e:
#                 logger.error(f"无法重命名日志文件: {e}")
#         # 调用父类的doRollover方法
#         super().doRollover()

# 自定义 namer 函数，用于去掉日期后缀
def namer(default_name):
    # 计算前一天的时间
    current_time = datetime.now() - timedelta(days=1)
    current_date = current_time.strftime('%Y-%m-%d')
    log_file = f'日志log/日志.{current_date}.txt'
    # 默认情况下，轮转后的文件名会添加日期后缀，这里去掉后缀
    return os.path.join(os.path.dirname(default_name), os.path.basename(log_file))
# 创建一个选品logger
logger = logging.getLogger('detailLogger')
logger.setLevel(logging.DEBUG)  # 设置日志级别
# 创建一个handler，用于写入文件，并根据时间自动轮换日志文件
detail_handler = TimedRotatingFileHandler('日志log/日志.txt', when='midnight', interval=1, backupCount=30,encoding='utf-8')
detail_handler.setFormatter(logging.Formatter('%(asctime)s - %(message)s'))
# 设置 namer 函数
detail_handler.namer = namer
# detail_handler.suffix = "%Y%m%d.txt"
# 添加handler到logger
logger.addHandler(detail_handler)

# 配置日志记录器
logger_cmd = logging.getLogger('logger_cmd')
logger_cmd.setLevel(logging.DEBUG)
# 配置控制台处理器和格式器
console_handler = logging.StreamHandler()
console_handler.setLevel(logging.DEBUG)
formatter = logging.Formatter('[%(asctime)s] %(message)s')
console_handler.setFormatter(formatter)
# 将处理器添加到记录器中
logger_cmd.addHandler(console_handler)

class MailSenderApp(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setWindowTitle('Mail Sender')
        self.setGeometry(100, 100, 200, 200)

        main_layout = QVBoxLayout()
        main_layout.setAlignment(Qt.AlignmentFlag.AlignLeft)  # 设置垂直布局居中

        # 创建标签和输入框，并将它们放在一个水平布局中
        def create_row(label_text):
            layout = QHBoxLayout()
            label = QLabel(label_text, self)
            edit = QLineEdit(self)
            edit.setFixedWidth(300)  # 设置输入框的固定宽度为500
            layout.addWidget(label)
            layout.addWidget(edit)
            return layout, edit

        self.phone_layout, self.phone_edit = create_row('手机号码:')
        self.session_layout, self.session_edit = create_row('Session:')
        self.sender_email_layout, self.sender_email_edit = create_row('发送人邮箱号:')
        self.receiver_email_layout, self.receiver_email_edit = create_row('接受人邮箱号:')
        self.smtp_proxy_layout, self.smtp_proxy_edit = create_row('邮箱SMTP代理:')
        self.smtp_account_layout, self.smtp_account_edit = create_row('SMTP账号:')
        self.smtp_password_layout, self.smtp_password_edit = create_row('SMTP密码:')
        self.email_alias_layout, self.email_alias_edit = create_row('邮箱特殊代号:')
        self.scan_interval_layout, self.scan_interval_edit = create_row('扫描间隔时间:')
        self.error_count_layout, self.error_count_edit = create_row('异常次数\n(超出则退出扫描):')
        self.success_scan_interval_layout, self.success_scan_interval_edit = create_row('没有短信验证时\n中间间隔时间(秒):')
        self.you_scan_interval_layout, self.you_scan_interval_edit = create_row('有短信验证时\n等待时间(秒):')

        # 将水平布局添加到垂直布局中
        for layout in [
            self.phone_layout,
            self.session_layout,
            self.sender_email_layout,
            self.receiver_email_layout,
            self.smtp_proxy_layout,
            self.smtp_account_layout,
            self.smtp_password_layout,
            self.email_alias_layout,
            self.scan_interval_layout,
            self.error_count_layout,
            self.success_scan_interval_layout,
            self.you_scan_interval_layout
        ]:
            main_layout.addLayout(layout)

        # 创建按钮
        self.save_button = QPushButton('保存', self)
        self.save_button.clicked.connect(self.save_settings)

        self.start_scan_button = QPushButton('开启扫描', self)
        self.start_scan_button.clicked.connect(self.start_scan)

        self.stop_scan_button = QPushButton('关闭扫描', self)
        self.stop_scan_button.clicked.connect(self.stop_scan)

        # 创建一个水平布局来放置按钮
        button_layout = QHBoxLayout()
        button_layout.addWidget(self.save_button)
        button_layout.addWidget(self.start_scan_button)
        button_layout.addWidget(self.stop_scan_button)

        # 将按钮布局添加到主布局中
        main_layout.addLayout(button_layout)

        # 设置主窗口的布局
        container = QWidget()
        container.setLayout(main_layout)
        container.setMaximumWidth(300)  # 设置容器的最大宽度为1000
        main_window_layout = QVBoxLayout()
        main_window_layout.addWidget(container, alignment=Qt.AlignmentFlag.AlignLeft)
        self.setLayout(main_window_layout)

        # 从数据库中读取数据并填充到输入框中
        self.load_settings()

    def save_settings(self):
        phone = self.phone_edit.text()
        session = self.session_edit.text()
        sender_email = self.sender_email_edit.text()
        receiver_email = self.receiver_email_edit.text()
        smtp_proxy = self.smtp_proxy_edit.text()
        smtp_account = self.smtp_account_edit.text()
        smtp_password = self.smtp_password_edit.text()
        email_alias = self.email_alias_edit.text()
        scan_interval = self.scan_interval_edit.text()
        error_count = self.error_count_edit.text()
        success_scan_interval = self.success_scan_interval_edit.text()
        you_scan_interval = self.you_scan_interval_edit.text()

        # 保存到SQLite数据库
        conn = sqlite3.connect('settings.db')
        cursor = conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS settings (
                            phone TEXT,
                            session TEXT,
                            sender_email TEXT,
                            receiver_email TEXT,
                            smtp_proxy TEXT,
                            smtp_account TEXT,
                            smtp_password TEXT,
                            email_alias TEXT,
                            scan_interval TEXT,
                            error_count TEXT,
                            success_scan_interval TEXT,
                            you_scan_interval TEXT
                        )''')
        cursor.execute('''DELETE FROM settings''')  # 删除现有数据
        cursor.execute('''INSERT INTO settings (
                            phone,
                            session,
                            sender_email,
                            receiver_email,
                            smtp_proxy,
                            smtp_account,
                            smtp_password,
                            email_alias,
                            scan_interval,
                            error_count,success_scan_interval,you_scan_interval
                        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?,?,?,?)''',
                       (phone, session, sender_email, receiver_email, smtp_proxy, smtp_account, smtp_password, email_alias, scan_interval,error_count,success_scan_interval,you_scan_interval))
        conn.commit()
        conn.close()
        # 提示保存成功
        QMessageBox.information(self, '保存成功', '设置已保存到数据库。')

    def load_settings(self):
        # 从SQLite数据库中读取数据
        conn = sqlite3.connect('settings.db')
        cursor = conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS settings (
                            phone TEXT,
                            session TEXT,
                            sender_email TEXT,
                            receiver_email TEXT,
                            smtp_proxy TEXT,
                            smtp_account TEXT,
                            smtp_password TEXT,
                            email_alias TEXT,
                            scan_interval TEXT,
                            error_count TEXT,
                            success_scan_interval TEXT,
                            you_scan_interval TEXT
                        )''')
        cursor.execute('''SELECT * FROM settings''')
        row = cursor.fetchone()
        conn.close()

        if row:
            self.phone_edit.setText(row[0])
            self.session_edit.setText(row[1])
            self.sender_email_edit.setText(row[2])
            self.receiver_email_edit.setText(row[3])
            self.smtp_proxy_edit.setText(row[4])
            self.smtp_account_edit.setText(row[5])
            self.smtp_password_edit.setText(row[6])
            self.email_alias_edit.setText(row[7])
            self.scan_interval_edit.setText(row[8])
            self.error_count_edit.setText(row[9])
            self.success_scan_interval_edit.setText(row[10])
            self.you_scan_interval_edit.setText(row[11])


    def start_scan(self):
        # 实现开启扫描的逻辑
        # 获取session的值
        session = self.session_edit.text()
        # 获取发送人邮箱号
        sender_email = self.sender_email_edit.text()
        # 获取接受人邮箱号
        receiver_email = self.receiver_email_edit.text()
        smtp_proxy = self.smtp_proxy_edit.text()
        smtp_account = self.smtp_account_edit.text()
        smtp_password = self.smtp_password_edit.text()
        email_alias = self.email_alias_edit.text()
        # 获取间隔时间
        scan_interval = self.scan_interval_edit.text()
        # 异常次数
        error_count = self.error_count_edit.text()
        # 获取间隔时间
        success_scan_interval = self.success_scan_interval_edit.text()
        # 获取间隔时间
        you_scan_interval = self.you_scan_interval_edit.text()

        logger.info(f'session:{session}')
        logger.info(f'发送人邮箱号：sender_email:{sender_email}')
        logger.info(f'接收人邮箱号：receiver_email:{receiver_email}')
        logger.info(f'smtp代理：smtp_proxy:{smtp_proxy}')
        logger.info(f'smtp账号：smtp_account:{smtp_account}')
        logger.info(f'smtp密码：smtp_password:{smtp_password}')
        logger.info(f'邮箱特殊代号：email_alias:{email_alias}')
        logger.info(f'间隔时长（秒）：scan_interval:{scan_interval}')
        logger.info(f'异常次数：error_count:{int(error_count)}')
        logger.info(f'没有短信验证中间间隔时长（秒）：success_scan_interval:{success_scan_interval}')
        logger.info(f'有短信验证等待间隔时长（秒）：you_scan_interval:{you_scan_interval}')

        logger_cmd.info(f'session:{session}')
        logger_cmd.info(f'发送人邮箱号：sender_email:{sender_email}')
        logger_cmd.info(f'接收人邮箱号：receiver_email:{receiver_email}')
        logger_cmd.info(f'smtp代理：smtp_proxy:{smtp_proxy}')
        logger_cmd.info(f'smtp账号：smtp_account:{smtp_account}')
        logger_cmd.info(f'smtp密码：smtp_password:{smtp_password}')
        logger_cmd.info(f'邮箱特殊代号：email_alias:{email_alias}')
        logger_cmd.info(f'间隔时长（秒）：scan_interval:{scan_interval}')
        logger_cmd.info(f'异常次数：error_count:{int(error_count)}')
        logger_cmd.info(f'没有短信验证中间间隔时长（秒）：success_scan_interval:{success_scan_interval}')
        logger_cmd.info(f'有短信验证等待间隔时长（秒）：you_scan_interval:{you_scan_interval}')

        # self.start_scan_button 无法点击
        self.start_scan_button.setEnabled(False)

        global stop_flag
        stop_flag = False
        # 清空表
        logger.info("清空表sms_codes")
        conn = sqlite3.connect('settings.db')
        cursor = conn.cursor()
        cursor.execute('''CREATE TABLE IF NOT EXISTS sms_codes (edit_content TEXT, send_content_short TEXT)''')
        cursor.execute('delete from sms_codes')
        conn.commit()
        conn.close()
        # 创建一个线程，并启动线程，线程每间隔10时间执行一下extract_and_save.py中的run方法
        thread = threading.Thread(target=thread_function, args=(session, sender_email, receiver_email, smtp_proxy, smtp_account, smtp_password, email_alias,scan_interval,error_count,success_scan_interval,you_scan_interval,self))
        thread.start()
        # thread_function(session, sender_email, receiver_email, smtp_proxy, smtp_account, smtp_password, email_alias,scan_interval,error_count,success_scan_interval,you_scan_interval,self)
        logger.info("扫描已开启")
        logger_cmd.info(f'扫描已开启')
        QMessageBox.information(self, '扫描已开启', '扫描已开启。')

    def stop_scan(self):
        # 获取全局的变量 stop_flag
        global stop_flag
        stop_flag = True
        logger.info("扫描关闭中，请等待")
        logger_cmd.info(f'扫描关闭中，请等待')
        # QMessageBox.information(self, '扫描关闭中，请等待', '扫描关闭中，请等待。')

def thread_function(session, sender_email, receiver_email, smtp_proxy, smtp_account, smtp_password, email_alias,scan_interval,error_count,success_scan_interval,you_scan_interval,self):
    #获取 全局的变量 stop_flag
    global stop_flag
    stop_back_flag = 'success'
    iconCount = 0

    while True:
        session = self.session_edit.text()
        logger.info(f'扫描：session = {session}')
        # stop_flag 为true 则跳出
        if stop_flag:
            logger.info(f'扫描已成功关闭')
            logger_cmd.info(f'扫描已成功关闭')
            # self.start_scan_button.setEnabled(True)
            QMetaObject.invokeMethod(self.start_scan_button, "setEnabled", Qt.QueuedConnection, Q_ARG(bool, True))
            return
        stop1_flag = run(
            session=session,
            sender_email=sender_email,
            receiver_email=receiver_email,
            smtp_proxy=smtp_proxy,
            smtp_account=smtp_account,
            smtp_password=smtp_password,
            email_alias=email_alias,
            error_count=error_count,
            you_scan_interval=you_scan_interval,
            logger=logger
        )
        logger.info(f'没有短信验证标志： {stop1_flag}')
        if stop1_flag == 'stop':
            logger_cmd.info(f'异常{error_count}次，暂停！')
            # self.start_scan_button.setEnabled(True)
            QMetaObject.invokeMethod(self.start_scan_button, "setEnabled", Qt.QueuedConnection, Q_ARG(bool, True))
            return
        elif stop1_flag == 'success':
            if stop_back_flag == 'error not stop':
                logger_cmd.info(f'第{iconCount}次无验证，等待{float(success_scan_interval)}秒！')
                logger.info(f"上一轮有短信验证，本次没有短信验证时，间隔{float(success_scan_interval)}秒")
                time.sleep(float(success_scan_interval))
            else:
                logger.info(f"间隔{float(scan_interval)}秒")
                logger_cmd.info(f'无验证，等待{float(scan_interval)}秒！')
                time.sleep(float(scan_interval))
            iconCount = 0
        else:
            iconCount += 1
            logger.info(f"间隔{float(scan_interval)}秒")
            time.sleep(float(scan_interval))
        stop_back_flag = stop1_flag

if __name__ == "__main__":
    app = QApplication(sys.argv)
    ex = MailSenderApp()
    ex.show()
    sys.exit(app.exec())