From 92b3e30e63273df39d7dbf370e9e40ff72ddd324 Mon Sep 17 00:00:00 2001 From: Holaplace <45121260+Holaplace@users.noreply.github.com> Date: Mon, 9 Sep 2019 14:54:19 +0800 Subject: [PATCH] uodate to alpha version --- linkSHUPath.py | 4 +- linkSHU.py => linkSHU_(alpha).py | 279 ++++++++++--------- shuClient.py => linkUI.py | 444 +++++++++++++++++-------------- netName.py | 15 +- pic2Py.py | 20 ++ requirements.txt | 11 + ruijie.py | 73 +++-- timg_png.py | 2 +- wifiConnect.py | 54 ++++ wireConnect.py | 9 +- 10 files changed, 530 insertions(+), 381 deletions(-) rename linkSHU.py => linkSHU_(alpha).py (73%) rename shuClient.py => linkUI.py (64%) create mode 100644 pic2Py.py create mode 100644 requirements.txt create mode 100644 wifiConnect.py diff --git a/linkSHUPath.py b/linkSHUPath.py index 7ff2f42..7a295fd 100644 --- a/linkSHUPath.py +++ b/linkSHUPath.py @@ -1,8 +1,8 @@ -from os import getenv, makedirs +from os import path, makedirs def shuPath(): - rootPath = getenv('SYSTEMROOT') + rootPath = path.expanduser('~') try: makedirs(rootPath + r'\linkSHU') addrSHU = rootPath + r'\linkSHU' diff --git a/linkSHU.py b/linkSHU_(alpha).py similarity index 73% rename from linkSHU.py rename to linkSHU_(alpha).py index 4cc10b6..367b77b 100644 --- a/linkSHU.py +++ b/linkSHU_(alpha).py @@ -1,125 +1,154 @@ -# -*- coding: utf-8 -*- - -import sys, \ - os -if hasattr(sys, 'frozen'): - os.environ['PATH'] = sys._MEIPASS + ";" + os.environ['PATH'] - -from sys import argv, exit -from shuClient import Ui_MainWindow -from wireConnect import wire_connect_status -from ruijie import shuConnect -from PyQt5.QtWidgets import QMainWindow, QApplication -from PyQt5.QtCore import QSettings, Qt, QTimer -from PyQt5.QtGui import QIcon -from logo_png import img as logo -import base64 -from linkSHUPath import shuPath - - -linkpath = shuPath() - -tmp = open(linkpath + r'\logo.png', 'wb') -tmp.write(base64.b64decode(logo)) -tmp.close() - - -class shuUi(QMainWindow, Ui_MainWindow): - def __init__(self, parent=None): - super(shuUi, self).__init__(parent) - self.setupUi(self) - - self.setWindowTitle('linkSHU') - self.setWindowIcon(QIcon(linkpath + r'\logo.png')) - - self.resize(391, 282) - self.setFixedSize(self.width(), self.height()) - self.setWindowFlags(Qt.WindowCloseButtonHint) - - self.input_user.setPlaceholderText("请输入用户名") - self.input_passwd.setPlaceholderText("请输入密码") - self.updateLabel.setText("关于 & 更新") - self.updateLabel.setOpenExternalLinks(True) - - self.init_login_info() - self.wireButton.clicked.connect(self.on_pushButton_enter_clicked) - - # 自动登录 - self.timer0 = QTimer(self) - self.timer0.timeout.connect(self.goto_autologin) - self.timer0.setSingleShot(True) - self.timer0.start(1000) - - # 保存登录信息 - def save_login_info(self): - settings = QSettings(linkpath + r"\config.ini", QSettings.IniFormat) - settings.setValue("account", self.input_user.text()) - settings.setValue("password", self.input_passwd.text()) - settings.setValue("remeberpassword", self.passwdCB.isChecked()) - settings.setValue("autologin", self.auto_login.isChecked()) - - # 初始化登录信息 - def init_login_info(self): - settings = QSettings(linkpath + r"\config.ini", QSettings.IniFormat) - the_account =settings.value("account") - the_password = settings.value("password") - the_remeberpassword = settings.value("remeberpassword") - the_autologin = settings.value("autologin") - - self.input_user.setText(the_account) - # 记住密码判断 - if the_remeberpassword == "true" or the_remeberpassword is True: - self.passwdCB.setChecked(True) - self.input_passwd.setText(the_password) - - # 自动登录判断 - if the_autologin == "true" or the_autologin is True: - self.auto_login.setChecked(True) - - # 自动登录 - def goto_autologin(self): - if self.auto_login.isChecked() is True: - self.on_pushButton_enter_clicked() - - def on_pushButton_enter_clicked(self): - # 账号密码NULL判断 - if self.input_user.text() == "" or self.input_passwd.text() == "": - return - - self.auto_login.stateChanged.connect(self.cancel_autologin) - - # 保存登录信息 - self.save_login_info() - - self.wireConnect() - - def cancel_autologin(self): - if not self.auto_login.isChecked(): - settings = QSettings(linkpath + r"\config.ini", QSettings.IniFormat) - settings.setValue("autologin", False) - - def wireConnect(self): - # 账号密码NULL判断 - if self.input_user.text() == "" or self.input_passwd.text() == "": - return - - user = int(self.input_user.text()) - passwd = str(self.input_passwd.text()) - s = wire_connect_status(user, passwd) - self.status.setText(s) - - def stopConnect(self): - shu = shuConnect() - s = shu.logOut() - self.status.setText(s) - - -if __name__ == "__main__": - app = QApplication(argv) - ui = shuUi() - - ui.wireButton.clicked.connect(ui.wireConnect) - ui.logout.clicked.connect(ui.stopConnect) - - ui.show() - exit(app.exec_()) +# -*- coding: utf-8 -*- + +import sys, \ + os +if hasattr(sys, 'frozen'): + os.environ['PATH'] = sys._MEIPASS + ";" + os.environ['PATH'] + +from sys import argv, exit +from linkUI import Ui_MainWindow +from wireConnect import wire_connect_status +from wifiConnect import wifi_connect_status +from ruijie import shuConnect +from PyQt5.QtWidgets import QMainWindow, QApplication +from PyQt5.QtCore import QSettings, Qt, QTimer +from PyQt5.QtGui import QIcon +from logo_png import img as logo +from base64 import b64decode +from linkSHUPath import shuPath + + +linkpath = shuPath() + +sss = os.path.exists(linkpath + r'\logo.png') +if not sss: + tmp = open(linkpath + r'\logo.png', 'wb') + tmp.write(b64decode(logo)) + tmp.close() +else: + pass + + +class shuUi(QMainWindow, Ui_MainWindow): + def __init__(self, parent=None): + super(shuUi, self).__init__(parent) + self.setupUi(self) + + self.setWindowTitle('linkSHU (alpha)') + self.setWindowIcon(QIcon(linkpath + r'\logo.png')) + + self.setFixedSize(self.width(), self.height()) + self.setWindowFlags(Qt.WindowCloseButtonHint) + + self.input_user.setPlaceholderText("请输入用户名") + self.input_passwd.setPlaceholderText("请输入密码") + self.updateLabel.setText("关于 & 更新") + self.updateLabel.setOpenExternalLinks(True) + + self.init_login_info() + self.login.clicked.connect(self.on_pushButton_enter_clicked) + + # 自动登录 + self.timer0 = QTimer(self) + self.timer0.timeout.connect(self.goto_autologin) + self.timer0.setSingleShot(True) + self.timer0.start(1000) + + # 保存登录信息 + def save_login_info(self): + settings = QSettings(linkpath + r"\config.ini", QSettings.IniFormat) + settings.setValue("account", self.input_user.text()) + settings.setValue("password", self.input_passwd.text()) + settings.setValue("remeberpassword", self.passwdCB.isChecked()) + settings.setValue("autologin", self.auto_login.isChecked()) + settings.setValue("loginStyle", self.comboBox.currentIndex()) + + # 初始化登录信息 + def init_login_info(self): + settings = QSettings(linkpath + r"\config.ini", QSettings.IniFormat) + the_account =settings.value("account") + the_password = settings.value("password") + the_remeberpassword = settings.value("remeberpassword") + the_autologin = settings.value("autologin") + the_loginStyle = int(settings.value("loginStyle")) + + self.input_user.setText(the_account) + # 记住密码判断 + if the_remeberpassword == "true" or the_remeberpassword is True: + self.passwdCB.setChecked(True) + self.input_passwd.setText(the_password) + + # 自动登录判断 + if the_autologin == "true" or the_autologin is True: + self.auto_login.setChecked(True) + + # 登录方式判断 + if the_autologin is not int(0): + self.comboBox.setCurrentIndex(the_loginStyle) + + # 自动登录 + def goto_autologin(self): + if self.auto_login.isChecked() is True: + self.on_pushButton_enter_clicked() + + def on_pushButton_enter_clicked(self): + # 账号密码NULL判断 + if self.input_user.text() == "" or self.input_passwd.text() == "": + return + + self.auto_login.stateChanged.connect(self.cancel_autologin) + + # 保存登录信息 + self.save_login_info() + self.connectStyle() + + def cancel_autologin(self): + if not self.auto_login.isChecked(): + settings = QSettings(linkpath + r"\config.ini", QSettings.IniFormat) + settings.setValue("autologin", False) + + def connectStyle(self): + try: + if self.comboBox.currentIndex() is int(1): + self.wireConnect() + elif self.comboBox.currentIndex() is int(2): + self.wifiConnect() + except Exception as e: + self.status.setText(e) + + def wireConnect(self): + # 账号密码NULL判断 + if self.input_user.text() == "" or self.input_passwd.text() == "": + return + + user = int(self.input_user.text()) + passwd = str(self.input_passwd.text()) + s = wire_connect_status(user, passwd) + self.status.setText(s) + + def wifiConnect(self): + # 账号密码NULL判断 + if self.input_user.text() == "" or self.input_passwd.text() == "": + return + + user = int(self.input_user.text()) + passwd = str(self.input_passwd.text()) + + s = wifi_connect_status(user, passwd) + self.status.setText(s) + + def stopConnect(self): + shu = shuConnect() + s = shu.logOut() + self.status.setText(s) + + +if __name__ == "__main__": + app = QApplication(argv) + ui = shuUi() + + ui.login.clicked.connect(ui.connectStyle) + ui.logout.clicked.connect(ui.stopConnect) + + ui.show() + exit(app.exec_()) diff --git a/shuClient.py b/linkUI.py similarity index 64% rename from shuClient.py rename to linkUI.py index 3196e20..2928487 100644 --- a/shuClient.py +++ b/linkUI.py @@ -1,205 +1,239 @@ -# -*- coding: utf-8 -*- -import sys, os -if hasattr(sys, 'frozen'): - os.environ['PATH'] = sys._MEIPASS + ";" + os.environ['PATH'] - -from PyQt5.QtWidgets import QWidget, QLabel, QHBoxLayout, QGroupBox, QGridLayout, QLineEdit, QPushButton, QTextBrowser, QCheckBox -from PyQt5.QtGui import QFont, QPixmap, QPalette, QColor, QCursor, QBrush -from PyQt5.QtCore import QRect, Qt, QMetaObject, QCoreApplication -import base64 -from timg_png import img as timg -from linkSHUPath import shuPath - - -linkpath = shuPath() - - -tmp = open(linkpath + r'\timg.png', 'wb') -tmp.write(base64.b64decode(timg)) -tmp.close() - - -class Ui_MainWindow(object): - def setupUi(self, MainWindow): - MainWindow.setObjectName("MainWindow") - MainWindow.resize(391, 282) - font = QFont() - font.setPointSize(11) - MainWindow.setFont(font) - self.centralwidget = QWidget(MainWindow) - self.centralwidget.setObjectName("centralwidget") - self.groupBox = QGroupBox(self.centralwidget) - self.groupBox.setGeometry(QRect(10, 70, 231, 171)) - self.groupBox.setTitle("") - self.groupBox.setObjectName("groupBox") - self.gridLayoutWidget = QWidget(self.groupBox) - self.gridLayoutWidget.setGeometry(QRect(9, 10, 213, 91)) - self.gridLayoutWidget.setObjectName("gridLayoutWidget") - self.gridLayout = QGridLayout(self.gridLayoutWidget) - self.gridLayout.setContentsMargins(0, 0, 0, 0) - self.gridLayout.setObjectName("gridLayout") - self.user = QLabel(self.gridLayoutWidget) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(11) - self.user.setFont(font) - self.user.setAlignment(Qt.AlignCenter) - self.user.setObjectName("user") - self.gridLayout.addWidget(self.user, 0, 0, 1, 1) - self.passwd = QLabel(self.gridLayoutWidget) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(11) - self.passwd.setFont(font) - self.passwd.setAlignment(Qt.AlignCenter) - self.passwd.setObjectName("passwd") - self.gridLayout.addWidget(self.passwd, 1, 0, 1, 1) - self.input_user = QLineEdit(self.gridLayoutWidget) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(11) - self.input_user.setFont(font) - self.input_user.setText("") - self.input_user.setAlignment(Qt.AlignLeading|Qt.AlignLeft|Qt.AlignVCenter) - self.input_user.setObjectName("input_user") - self.gridLayout.addWidget(self.input_user, 0, 1, 1, 1) - self.input_passwd = QLineEdit(self.gridLayoutWidget) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(11) - self.input_passwd.setFont(font) - self.input_passwd.setFocusPolicy(Qt.StrongFocus) - self.input_passwd.setContextMenuPolicy(Qt.DefaultContextMenu) - self.input_passwd.setText("") - self.input_passwd.setEchoMode(QLineEdit.Password) - self.input_passwd.setAlignment(Qt.AlignLeading|Qt.AlignLeft|Qt.AlignVCenter) - self.input_passwd.setObjectName("input_passwd") - self.gridLayout.addWidget(self.input_passwd, 1, 1, 1, 1) - self.horizontalLayoutWidget = QWidget(self.groupBox) - self.horizontalLayoutWidget.setGeometry(QRect(10, 102, 211, 26)) - self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget") - self.horizontalLayout_7 = QHBoxLayout(self.horizontalLayoutWidget) - self.horizontalLayout_7.setContentsMargins(0, 0, 0, 0) - self.horizontalLayout_7.setObjectName("horizontalLayout_7") - self.passwdCB = QCheckBox(self.horizontalLayoutWidget) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(11) - self.passwdCB.setFont(font) - self.passwdCB.setObjectName("passwdCB") - self.horizontalLayout_7.addWidget(self.passwdCB) - self.auto_login = QCheckBox(self.horizontalLayoutWidget) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(11) - self.auto_login.setFont(font) - self.auto_login.setObjectName("auto_login") - self.horizontalLayout_7.addWidget(self.auto_login) - self.horizontalLayoutWidget_3 = QWidget(self.groupBox) - self.horizontalLayoutWidget_3.setGeometry(QRect(10, 130, 211, 31)) - self.horizontalLayoutWidget_3.setObjectName("horizontalLayoutWidget_3") - self.horizontalLayout_2 = QHBoxLayout(self.horizontalLayoutWidget_3) - self.horizontalLayout_2.setContentsMargins(0, 0, 0, 0) - self.horizontalLayout_2.setObjectName("horizontalLayout_2") - self.wireButton = QPushButton(self.horizontalLayoutWidget_3) - font = QFont() - font.setFamily("微软雅黑") - self.wireButton.setFont(font) - self.wireButton.setObjectName("wireButton") - self.horizontalLayout_2.addWidget(self.wireButton) - self.groupBox_2 = QGroupBox(self.centralwidget) - self.groupBox_2.setGeometry(QRect(240, 70, 141, 171)) - self.groupBox_2.setTitle("") - self.groupBox_2.setObjectName("groupBox_2") - self.status_lable = QLabel(self.groupBox_2) - self.status_lable.setGeometry(QRect(30, 10, 71, 20)) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(11) - self.status_lable.setFont(font) - self.status_lable.setAlignment(Qt.AlignCenter) - self.status_lable.setObjectName("status_lable") - self.status = QTextBrowser(self.groupBox_2) - self.status.setGeometry(QRect(10, 40, 121, 81)) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(7) - self.status.setFont(font) - self.status.setObjectName("status") - self.logout = QPushButton(self.groupBox_2) - self.logout.setGeometry(QRect(10, 130, 121, 28)) - font = QFont() - font.setFamily("微软雅黑") - self.logout.setFont(font) - self.logout.setObjectName("logout") - self.groupBox_3 = QGroupBox(self.centralwidget) - self.groupBox_3.setGeometry(QRect(10, 240, 371, 31)) - self.groupBox_3.setTitle("") - self.groupBox_3.setObjectName("groupBox_3") - self.horizontalLayoutWidget_2 = QWidget(self.groupBox_3) - self.horizontalLayoutWidget_2.setGeometry(QRect(0, 0, 371, 31)) - self.horizontalLayoutWidget_2.setObjectName("horizontalLayoutWidget_2") - self.horizontalLayout_8 = QHBoxLayout(self.horizontalLayoutWidget_2) - self.horizontalLayout_8.setContentsMargins(0, 0, 0, 0) - self.horizontalLayout_8.setObjectName("horizontalLayout_8") - self.updateLabel = QLabel(self.horizontalLayoutWidget_2) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(10) - self.updateLabel.setFont(font) - self.updateLabel.setCursor(QCursor(Qt.PointingHandCursor)) - self.updateLabel.setToolTip("") - self.updateLabel.setAlignment(Qt.AlignCenter) - self.updateLabel.setObjectName("updateLabel") - self.horizontalLayout_8.addWidget(self.updateLabel) - self.groupBox_4 = QGroupBox(self.centralwidget) - self.groupBox_4.setGeometry(QRect(10, 10, 371, 61)) - self.groupBox_4.setTitle("") - self.groupBox_4.setObjectName("groupBox_4") - self.layoutWidget = QWidget(self.groupBox_4) - self.layoutWidget.setGeometry(QRect(80, 10, 181, 43)) - self.layoutWidget.setObjectName("layoutWidget") - self.horizontalLayout = QHBoxLayout(self.layoutWidget) - self.horizontalLayout.setContentsMargins(0, 0, 0, 0) - self.horizontalLayout.setObjectName("horizontalLayout") - self.logo = QLabel(self.layoutWidget) - self.logo.setText("") - self.logo.setPixmap(QPixmap(linkpath + r'\timg.png')) - self.logo.setObjectName("logo") - self.horizontalLayout.addWidget(self.logo) - self.text = QLabel(self.layoutWidget) - palette = QPalette() - brush = QBrush(QColor(0, 85, 255)) - brush.setStyle(Qt.SolidPattern) - palette.setBrush(QPalette.Active, QPalette.Text, brush) - brush = QBrush(QColor(0, 85, 255)) - brush.setStyle(Qt.SolidPattern) - palette.setBrush(QPalette.Inactive, QPalette.Text, brush) - brush = QBrush(QColor(120, 120, 120)) - brush.setStyle(Qt.SolidPattern) - palette.setBrush(QPalette.Disabled, QPalette.Text, brush) - self.text.setPalette(palette) - font = QFont() - font.setFamily("微软雅黑") - font.setPointSize(14) - self.text.setFont(font) - self.text.setAlignment(Qt.AlignCenter) - self.text.setObjectName("text") - self.horizontalLayout.addWidget(self.text) - MainWindow.setCentralWidget(self.centralwidget) - - self.retranslateUi(MainWindow) - QMetaObject.connectSlotsByName(MainWindow) - - def retranslateUi(self, MainWindow): - _translate = QCoreApplication.translate - MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) - self.user.setText(_translate("MainWindow", "用户名")) - self.passwd.setText(_translate("MainWindow", "密 码")) - self.passwdCB.setText(_translate("MainWindow", "记住密码")) - self.auto_login.setText(_translate("MainWindow", "自动登录")) - self.wireButton.setText(_translate("MainWindow", "有线连接")) - self.status_lable.setText(_translate("MainWindow", "连接状态")) - self.logout.setText(_translate("MainWindow", "下线")) - self.updateLabel.setText(_translate("MainWindow", "关于 & 更新")) - self.text.setText(_translate("MainWindow", "校 园 网")) +# -*- coding: utf-8 -*- +import sys, \ + os +if hasattr(sys, 'frozen'): + os.environ['PATH'] = sys._MEIPASS + ";" + os.environ['PATH'] + +from PyQt5.QtWidgets import QWidget, QLabel, QHBoxLayout, QGroupBox, QGridLayout, QLineEdit, QPushButton, QTextBrowser, QCheckBox, QComboBox, QVBoxLayout +from PyQt5.QtGui import QFont, QPixmap, QPalette, QColor, QCursor, QBrush +from PyQt5.QtCore import QRect, Qt, QMetaObject, QCoreApplication + +from linkSHUPath import shuPath +from timg_png import img as timg +import base64 + + +linkpath = shuPath() + +sss = os.path.exists(linkpath + r'\timg.png') +if not sss: + tmp = open(linkpath + r'\timg.png', 'wb') + tmp.write(base64.b64decode(timg)) + tmp.close() +else: + pass + + +class Ui_MainWindow(object): + def setupUi(self, MainWindow): + MainWindow.setObjectName("MainWindow") + MainWindow.resize(433, 291) + font = QFont() + font.setPointSize(11) + MainWindow.setFont(font) + self.centralwidget = QWidget(MainWindow) + self.centralwidget.setObjectName("centralwidget") + self.groupBox = QGroupBox(self.centralwidget) + self.groupBox.setGeometry(QRect(10, 70, 231, 131)) + self.groupBox.setTitle("") + self.groupBox.setObjectName("groupBox") + self.gridLayoutWidget = QWidget(self.groupBox) + self.gridLayoutWidget.setGeometry(QRect(9, 10, 213, 91)) + self.gridLayoutWidget.setObjectName("gridLayoutWidget") + self.gridLayout = QGridLayout(self.gridLayoutWidget) + self.gridLayout.setContentsMargins(0, 0, 0, 0) + self.gridLayout.setObjectName("gridLayout") + self.input_user = QLineEdit(self.gridLayoutWidget) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(11) + self.input_user.setFont(font) + self.input_user.setText("") + self.input_user.setAlignment(Qt.AlignLeading|Qt.AlignLeft|Qt.AlignVCenter) + self.input_user.setObjectName("input_user") + self.gridLayout.addWidget(self.input_user, 0, 1, 1, 1) + self.user = QLabel(self.gridLayoutWidget) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(11) + self.user.setFont(font) + self.user.setAlignment(Qt.AlignCenter) + self.user.setObjectName("user") + self.gridLayout.addWidget(self.user, 0, 0, 1, 1) + self.input_passwd = QLineEdit(self.gridLayoutWidget) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(11) + self.input_passwd.setFont(font) + self.input_passwd.setFocusPolicy(Qt.StrongFocus) + self.input_passwd.setContextMenuPolicy(Qt.DefaultContextMenu) + self.input_passwd.setText("") + self.input_passwd.setEchoMode(QLineEdit.Password) + self.input_passwd.setAlignment(Qt.AlignLeading|Qt.AlignLeft|Qt.AlignVCenter) + self.input_passwd.setObjectName("input_passwd") + self.gridLayout.addWidget(self.input_passwd, 1, 1, 1, 1) + self.passwd = QLabel(self.gridLayoutWidget) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(11) + self.passwd.setFont(font) + self.passwd.setAlignment(Qt.AlignCenter) + self.passwd.setObjectName("passwd") + self.gridLayout.addWidget(self.passwd, 1, 0, 1, 1) + self.horizontalLayoutWidget = QWidget(self.groupBox) + self.horizontalLayoutWidget.setGeometry(QRect(10, 102, 211, 26)) + self.horizontalLayoutWidget.setObjectName("horizontalLayoutWidget") + self.horizontalLayout_7 = QHBoxLayout(self.horizontalLayoutWidget) + self.horizontalLayout_7.setContentsMargins(0, 0, 0, 0) + self.horizontalLayout_7.setObjectName("horizontalLayout_7") + self.passwdCB = QCheckBox(self.horizontalLayoutWidget) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(11) + self.passwdCB.setFont(font) + self.passwdCB.setObjectName("passwdCB") + self.horizontalLayout_7.addWidget(self.passwdCB) + self.auto_login = QCheckBox(self.horizontalLayoutWidget) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(11) + self.auto_login.setFont(font) + self.auto_login.setObjectName("auto_login") + self.horizontalLayout_7.addWidget(self.auto_login) + self.groupBox_2 = QGroupBox(self.centralwidget) + self.groupBox_2.setGeometry(QRect(240, 70, 181, 131)) + self.groupBox_2.setTitle("") + self.groupBox_2.setObjectName("groupBox_2") + self.verticalLayoutWidget = QWidget(self.groupBox_2) + self.verticalLayoutWidget.setGeometry(QRect(10, 10, 161, 111)) + self.verticalLayoutWidget.setObjectName("verticalLayoutWidget") + self.verticalLayout = QVBoxLayout(self.verticalLayoutWidget) + self.verticalLayout.setContentsMargins(0, 0, 0, 0) + self.verticalLayout.setObjectName("verticalLayout") + self.status_lable = QLabel(self.verticalLayoutWidget) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(11) + self.status_lable.setFont(font) + self.status_lable.setAlignment(Qt.AlignCenter) + self.status_lable.setObjectName("status_lable") + self.verticalLayout.addWidget(self.status_lable) + self.status = QTextBrowser(self.verticalLayoutWidget) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(9) + self.status.setFont(font) + self.status.setObjectName("status") + self.verticalLayout.addWidget(self.status) + self.groupBox_3 = QGroupBox(self.centralwidget) + self.groupBox_3.setGeometry(QRect(10, 250, 411, 31)) + self.groupBox_3.setTitle("") + self.groupBox_3.setObjectName("groupBox_3") + self.updateLabel = QLabel(self.groupBox_3) + self.updateLabel.setGeometry(QRect(150, 0, 111, 31)) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(10) + self.updateLabel.setFont(font) + self.updateLabel.setCursor(QCursor(Qt.PointingHandCursor)) + self.updateLabel.setToolTip("") + self.updateLabel.setAlignment(Qt.AlignCenter) + self.updateLabel.setObjectName("updateLabel") + self.groupBox_4 = QGroupBox(self.centralwidget) + self.groupBox_4.setGeometry(QRect(10, 0, 411, 71)) + self.groupBox_4.setTitle("") + self.groupBox_4.setObjectName("groupBox_4") + self.logo = QLabel(self.groupBox_4) + self.logo.setGeometry(QRect(80, 10, 250, 51)) + self.logo.setText("") + self.logo.setPixmap(QPixmap(linkpath + r'\timg.png')) + self.logo.setObjectName("logo") + self.text = QLabel(self.groupBox_4) + self.text.setGeometry(QRect(180, 10, 122, 49)) + palette = QPalette() + brush = QBrush(QColor(0, 85, 255)) + brush.setStyle(Qt.SolidPattern) + palette.setBrush(QPalette.Active, QPalette.Text, brush) + brush = QBrush(QColor(0, 85, 255, 128)) + brush.setStyle(Qt.NoBrush) + palette.setBrush(QPalette.Active, QPalette.PlaceholderText, brush) + brush = QBrush(QColor(0, 85, 255)) + brush.setStyle(Qt.SolidPattern) + palette.setBrush(QPalette.Inactive, QPalette.Text, brush) + brush = QBrush(QColor(0, 85, 255, 128)) + brush.setStyle(Qt.NoBrush) + palette.setBrush(QPalette.Inactive, QPalette.PlaceholderText, brush) + brush = QBrush(QColor(120, 120, 120)) + brush.setStyle(Qt.SolidPattern) + palette.setBrush(QPalette.Disabled, QPalette.Text, brush) + brush = QBrush(QColor(0, 85, 255, 128)) + brush.setStyle(Qt.NoBrush) + palette.setBrush(QPalette.Disabled, QPalette.PlaceholderText, brush) + self.text.setPalette(palette) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(14) + self.text.setFont(font) + self.text.setAlignment(Qt.AlignCenter) + self.text.setObjectName("text") + self.groupBox_5 = QGroupBox(self.centralwidget) + self.groupBox_5.setGeometry(QRect(240, 200, 181, 51)) + self.groupBox_5.setTitle("") + self.groupBox_5.setObjectName("groupBox_5") + self.login = QPushButton(self.groupBox_5) + self.login.setGeometry(QRect(10, 10, 91, 28)) + font = QFont() + font.setFamily("微软雅黑") + self.login.setFont(font) + self.login.setObjectName("login") + self.logout = QPushButton(self.groupBox_5) + self.logout.setGeometry(QRect(110, 10, 61, 28)) + font = QFont() + font.setFamily("微软雅黑") + self.logout.setFont(font) + self.logout.setObjectName("logout") + self.groupBox_6 = QGroupBox(self.centralwidget) + self.groupBox_6.setGeometry(QRect(10, 200, 231, 51)) + self.groupBox_6.setTitle("") + self.groupBox_6.setObjectName("groupBox_6") + self.linkStyle = QLabel(self.groupBox_6) + self.linkStyle.setGeometry(QRect(10, 0, 71, 41)) + font = QFont() + font.setFamily("微软雅黑") + font.setPointSize(11) + self.linkStyle.setFont(font) + self.linkStyle.setCursor(QCursor(Qt.ArrowCursor)) + self.linkStyle.setToolTip("") + self.linkStyle.setAlignment(Qt.AlignCenter) + self.linkStyle.setObjectName("linkStyle") + self.comboBox = QComboBox(self.groupBox_6) + self.comboBox.setGeometry(QRect(80, 10, 131, 26)) + font = QFont() + font.setFamily("微软雅黑") + self.comboBox.setFont(font) + self.comboBox.setLayoutDirection(Qt.LeftToRight) + self.comboBox.setObjectName("comboBox") + self.comboBox.addItem("") + self.comboBox.addItem("") + self.comboBox.addItem("") + MainWindow.setCentralWidget(self.centralwidget) + + self.retranslateUi(MainWindow) + QMetaObject.connectSlotsByName(MainWindow) + + def retranslateUi(self, MainWindow): + _translate = QCoreApplication.translate + MainWindow.setWindowTitle(_translate("MainWindow", "MainWindow")) + self.user.setText(_translate("MainWindow", "用户名")) + self.passwd.setText(_translate("MainWindow", "密 码")) + self.passwdCB.setText(_translate("MainWindow", "记住密码")) + self.auto_login.setText(_translate("MainWindow", "自动登录")) + self.status_lable.setText(_translate("MainWindow", "连接状态")) + self.updateLabel.setText(_translate("MainWindow", "关于 & 更新")) + self.text.setText(_translate("MainWindow", "校 园 网")) + self.login.setText(_translate("MainWindow", "连接 LogIn")) + self.logout.setText(_translate("MainWindow", "下线")) + self.linkStyle.setText(_translate("MainWindow", "连接方式")) + self.comboBox.setItemText(0, _translate("MainWindow", " 请选择")) + self.comboBox.setItemText(1, _translate("MainWindow", " 有线连接")) + self.comboBox.setItemText(2, _translate("MainWindow", " WIFI连接")) diff --git a/netName.py b/netName.py index 4ee9b4f..ffa87e2 100644 --- a/netName.py +++ b/netName.py @@ -1,9 +1,16 @@ from psutil import net_if_addrs -def netHi(): - s = net_if_addrs() - for key in s.keys(): +def netHiWifi(): + for key in net_if_addrs().keys(): + if 'WLAN' in key: + s = key + return s + + +def netHiWire(): + for key in net_if_addrs().keys(): if '以太' in key: s = key - return s + return s + diff --git a/pic2Py.py b/pic2Py.py new file mode 100644 index 0000000..6b764a9 --- /dev/null +++ b/pic2Py.py @@ -0,0 +1,20 @@ +import base64 + + +def pic2py(picture_name): + + open_pic = open("%s" % picture_name, 'rb') + b64str = base64.b64encode(open_pic.read()) + open_pic.close() + # 注意这边b64str一定要加上.decode() + write_data = 'img = "%s"' % b64str.decode() + f = open('%s.py' % picture_name.replace('.', '_'), 'w+') + f.write(write_data) + f.close() + + +if __name__ == '__main__': + pics = ["timg.png"] + for i in pics: + pic2py(i) + print("ok") diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..dc7a18a --- /dev/null +++ b/requirements.txt @@ -0,0 +1,11 @@ +# pip install -r requirements.txt +# pyinstaller -F -w -i logo.ico linkSHU_(alpha).py + +requests +pyqt5 +pywifi +pyinstaller +comtypes +IPy +psutil +PyQt5-stubs \ No newline at end of file diff --git a/ruijie.py b/ruijie.py index 5401d19..53ed9a6 100644 --- a/ruijie.py +++ b/ruijie.py @@ -1,18 +1,17 @@ # -*- coding: utf-8 -*- from requests import get, post -from time import strftime from json import dump, load from linkSHUPath import shuPath linkpath = shuPath() + class shuConnect: def __init__(self, user=0, passwd='shu'): self.user = user self.passwd = passwd - self.ssid = 'Shu(ForAll)' def check_connect(self): r = get("http://10.10.9.9:8080") @@ -22,25 +21,29 @@ def check_connect(self): return False def catch_data(self): - r = get("http://123.123.123.123/") - query_string = r.text - st = query_string.find("index.jsp?") + 10 - end = query_string.find("'") - query_string = query_string[st:end] - - data = {"userId": self.user, - "password": self.passwd, - "passwordEncrypt": "false", - "queryString": query_string, - "service": "", - "operatorPwd": "", - "operatorUserId": "", - "validcode": ""} - - with open(linkpath + r'\catch_data.json', 'w') as data_file: - dump(data, data_file) - - return data + try: + r = get("http://123.123.123.123/") + query_string = r.text + st = query_string.find("index.jsp?") + 10 + end = query_string.find("'") + query_string = query_string[st:end] + + data = {"userId": self.user, + "password": self.passwd, + "passwordEncrypt": "false", + "queryString": query_string, + "service": "", + "operatorPwd": "", + "operatorUserId": "", + "validcode": ""} + + with open(linkpath + r'\catch_data.json', 'w') as data_file: + dump(data, data_file) + + return data + except: + s = '频繁登录下线操作，可能该无线网卡MAC地址已被锐捷封禁. \n\n 补救方法：点击下方“关于&更新”' + return s def connect(self): r = post("http://10.10.9.9:8080/eportal/InterFace.do?method=login", data=self.catch_data()) @@ -53,27 +56,21 @@ def connect(self): return False, resp["message"] def start_connect(self): - t = strftime("%Y-%m-%d %H:%M:%S") + status = self.check_connect() + if status: + s = '已认证 & 用户已在线 \n' - try: - status = self.check_connect() - if status: - s = '已认证 & 用户已在线 \n' +t + else: + r, msg = self.connect() + if r: + s = '认证成功 & 用户上线\n' else: - r, msg = self.connect() - if r: - s = '认证成功 & 用户上线\n' + t - - else: - s = '认证失败\n' + t + msg + s = '认证失败\n' + msg - return s - except: - return + return s def logOut(self): - t = strftime("%Y-%m-%d %H:%M:%S") try: with open(linkpath + r'\catch_data.json', 'r') as data_file: logoutData = load(data_file) @@ -82,8 +79,8 @@ def logOut(self): r.encoding = "utf-8" resp = r.json() - s = resp["message"] + '\n' + t + s = resp["message"] + '\n' return s except IOError: - s = '提示：首次使用，打开浏览器，地址栏转到 \nhttp://10.10.9.9:8080 \n进行网络下线' + s = '提示：首次使用，请打开浏览器转到 http://10.10.9.9:8080 网络认证下线后，再使用客户端登录' return s diff --git a/timg_png.py b/timg_png.py index 23367aa..3c9ccf9 100644 --- a/timg_png.py +++ b/timg_png.py @@ -1 +1 @@ -img = "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" \ No newline at end of file +img = "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" \ No newline at end of file diff --git a/wifiConnect.py b/wifiConnect.py new file mode 100644 index 0000000..68b9178 --- /dev/null +++ b/wifiConnect.py @@ -0,0 +1,54 @@ +from pywifi import PyWiFi, Profile +from time import sleep +from ruijie import shuConnect +from psutil import net_if_stats +from netName import netHiWifi, netHiWire + + +nameHiwire = netHiWire() +nameHiwifi = netHiWifi() + + +def wifi_connect_status(user, passwd): + if not net_if_stats()[nameHiwifi].isup: # wifi未连接到Shu(ForAll) 或未打开WiFi开关 + s = connect_wifi(user, passwd) + return s + + else: # wifi已连接到internet + try: # wifi已连接到 Shu(ForAll) + s0 = "Shu(ForAll) 连接成功\n" + shu = shuConnect(user, passwd) + s = s0 + shu.start_connect() + return s + except: # wifi未连接到 Shu(ForAll)，重连... + s = connect_wifi(user, passwd) + return s + + +def connect_wifi(user, passwd): + if net_if_stats()[nameHiwire].isup: + s = '无线连接前，请先断开网线\n' + return s + else: + try: + wifi = PyWiFi() # 创建一个wifi对象 + iface = wifi.interfaces()[0] # 取第一个无限网卡 + + iface.disconnect() # 断开网卡连接 + profile = Profile() # 配置文件 + profile.ssid = "Shu(ForAll)" # wifi名称 + + iface.remove_all_network_profiles() # 删除其他配置文件 + tmp_profile = iface.add_network_profile(profile) # 加载配置文件 + + iface.connect(tmp_profile) # 连接 + sleep(0.5) # 不延时，wifi反应不过来 + + s0 = "Shu(ForAll) 连接成功\n" + shu = shuConnect(user, passwd) + s = s0 + shu.start_connect() + + except: + s = "无线网卡未打开，请打开 WLAN 开关\n" + + return s diff --git a/wireConnect.py b/wireConnect.py index 24851f0..b47c20c 100644 --- a/wireConnect.py +++ b/wireConnect.py @@ -1,15 +1,12 @@ from ruijie import shuConnect -from time import strftime from psutil import net_if_addrs, net_if_stats from IPy import IP from eduIP import eduIPlist -from netName import netHi +from netName import netHiWire def wire_connect_status(user, passwd): - t = strftime("%Y-%m-%d %H:%M:%S") - - nameHi = netHi() + nameHi = netHiWire() if net_if_stats()[nameHi].isup: @@ -26,5 +23,5 @@ def wire_connect_status(user, passwd): except: pass else: - s = '请检查网线是否插入 或 是否已连接到 SHU有线\n' + t + s = '请检查网线是否插入 或 是否已连接到 SHU有线\n' return s