def get_tasks(self):
self.ui.tw1.setRowCount(0)
mdb = MariaDB()
mdb.connect(self.MDBServer, self.MDBUser, self.MDBPasswd, "DokuMail")
task_list = mdb.get_users_tasks()
for task in task_list:
self.ui.tw1.setRowCount(self.ui.tw1.rowCount() + 1)
item = QtGui.QTableWidgetItem(task["id"])
self.ui.tw1.setItem(self.ui.tw1.rowCount() - 1, 0, item)
item = QtGui.QTableWidgetItem(task["name"])
self.ui.tw1.setItem(self.ui.tw1.rowCount() - 1, 1, item)
item = QtGui.QTableWidgetItem(task["type"])
self.ui.tw1.setItem(self.ui.tw1.rowCount() - 1, 2, item)
item = QtGui.QTableWidgetItem(task["date"])
self.ui.tw1.setItem(self.ui.tw1.rowCount() - 1, 3, item)
item = QtGui.QTableWidgetItem(task["status"])
self.ui.tw1.setItem(self.ui.tw1.rowCount() - 1, 4, item)
if mdb.get_signal():
if not self.isRead:
self.show()
QtGui.QMessageBox.information(self, "Задачи DokuMail", "У вас есть нерешённые проблемы!",
QtGui.QMessageBox.Yes)
self.isRead = True
mdb.close()
def on_login(self):
"""
Checking login and password in database and init start processes
in main window. After close login windows and show main window.
"""
self.loginTmr.stop()
state = False
if (self.ui.edLogin.text() == "") or (self.ui.edPasswd.text() == ""):
QtGui.QMessageBox.warning(self, 'Ошибка', 'Введите логин или пароль!', QtGui.QMessageBox.Yes)
return
if (self.ui.cbSave.checkState() == QtCore.Qt.Checked):
self.save_passwd()
mdb = MariaDB()
if not mdb.connect(self._mw.MDBServer, self._mw.MDBUser, self._mw.MDBPasswd, "DokuMail"):
QtGui.QMessageBox.critical(self, 'Ошибка', 'Ошибка соединения с Базой Данных!',
QtGui.QMessageBox.Yes)
return
state = mdb.check_login(self.ui.edLogin.text(), self.ui.edPasswd.text())
username = mdb.get_alias_by_user(self.ui.edLogin.text())
mdb.close()
if state == True:
self.hide()
WndParams().on_screen_center(self._mw)
self._mw.setWindowTitle("Doku (" + username + ")")
self._mw.show()
import platform
if platform.system() == "Windows" and self.isAuto:
QtCore.QTimer().singleShot(1500, self.finish)
self._mw.passwd = self.ui.edPasswd.text()
self._mw.user = self.ui.edLogin.text()
self._mw.loginWnd = self
self._mw.init_app()
else:
QtGui.QMessageBox.critical(self, 'Ошибка', 'Неверный логин или пароль!', QtGui.QMessageBox.Yes)
def run(self):
data = str
try:
data = AES256_decode_msg( self.conn.recv(1024), self.r_key )
data = json.loads(data)
except:
return
if data["header"] == self.header and data["type"] == "login":
self.usr = data["user"]
h_pwd = data["passwd"]
"""
Check user's login and password
"""
mdb = MariaDB()
if not mdb.connect(self.cfg["MariaDB"]["ip"], self.cfg["MariaDB"]["login"],
self.cfg["MariaDB"]["password"], self.cfg["MariaDB"]["base"]):
Log().local("SERVER", "Error connection to Database", LOG_CRITICAL, mdb)
return
if not mdb.check_login(self.usr, h_pwd):
Log().local(self.usr, "Access denided. Client disconnected.", LOG_CRITICAL, mdb)
mdb.close()
self.conn.close()
return
"""
User authorized
"""
answ = json.dumps({"header": self.header, "answ": "login-ok"})
self.conn.send( AES256_encode_msg(answ, self.r_key) )
"""
Reciveing files
"""
lfiles = str("")
now_date = datetime.date.today()
now_time = datetime.datetime.now()
now_time_str = str(now_time).split(" ")[1].split(".")[0]
data = AES256_decode_msg( self.conn.recv(1024), self.r_key )
data = json.loads(data)
"""
Get messages
"""
if data["type"] == 'get-message':
answ = {"header": self.header, "answ": ""}
msgInfo = mdb.get_msg_info(self.usr)
if msgInfo["type"] == "empty":
mdb.change_state(self.usr, "isMsg", 0)
answ["answ"] = "empty-msg"
self.conn.send(AES256_encode_msg(json.dumps(answ), self.r_key))
self.conn.close()
return
idMsg = msgInfo["name"]
fromMsg = msgInfo["from"]
timeMsg = msgInfo["time"]
answ = {"header": self.header, "answ": "msg", "From": mdb.get_alias_by_user(fromMsg), "Time": timeMsg}
self.conn.send(AES256_encode_msg(json.dumps(answ), self.r_key))
self.conn.recv(1024)
f = open("".join(("data/", self.usr, "/", idMsg, ".bin")), "rb")
self.conn.send(f.read())
f.close()
mdb.delete_message(self.usr, fromMsg, idMsg)
Log().local(self.usr, "Get new message", LOG_INFO, mdb)
"""
Reciveing files
"""
if data["type"] == 'get-files':
isUpdate = False
if data["operation"] == "update":
isUpdate = True
elif data["operation"] == 'download':
isUpdate = False
files = []
if not isUpdate:
files = mdb.get_file_list(self.usr)
else:
files = mdb.get_update_list()
if files == '':
answ = {"header": self.header, "type": "not-files"}
self.sock.send( AES256_encode_msg(json.dumps(answ), self.r_key ))
return
answ = {"header": self.header, "count": len(files)}
self.conn.send(AES256_encode_msg(json.dumps(answ), self.r_key))
self.conn.recv(1024)
dest = str
if isUpdate:
Log().local(self.usr, "Start update", LOG_INFO, mdb)
for sfile in files:
answ = {"header": self.header, "type": "sf", "filename": sfile}
self.conn.send(AES256_encode_msg(json.dumps(answ), self.r_key))
self.conn.recv(1024)
Log().local(self.usr, "Get file " + sfile, LOG_INFO, mdb)
if not isUpdate:
dest = "".join(("data/", self.usr, "/files/", sfile, ".bin"))
else:
dest = "data/update/" + sfile
f = open(dest, "rb")
while True:
data = f.read(4096)
if len(data) != 0:
self.conn.send(data)
else:
break
f.close()
self.conn.send(b"[end]")
if not isUpdate:
path = str
mdb.delete_file(self.usr, sfile)
os.remove("data/" + self.usr + "/files/" + sfile + ".bin")
self.conn.recv(1024).decode('utf-8')
Log().local(self.usr, "All files downloaded.", LOG_INFO, mdb)
answ = {"header": self.header, "type": "end-retrieve"}
self.conn.send(AES256_encode_msg(json.dumps(answ), self.r_key))
if not isUpdate:
mdb.change_state(self.usr, "isFiles", 0)
else:
mdb.change_state(self.usr, "isUpdate", 0)
self.conn.close()
return
"""
Send messages
"""
if data["type"] == "send-message":
toUsers = []
answ = {"header": self.header, "answ": ""}
if (data["ToUsers"] == "$ALL_USERS$") and (not mdb.check_user_admin(self.usr)):
answ["answ"] = "fail-access"
self.conn.send(json.dumps(answ).encode("utf-8"))
Log().local(self.usr, "User does not have privileges! Disconnected.", LOG_INFO, mdb)
self.conn.close()
return
answ["answ"] = "ok"
self.conn.send( AES256_encode_msg(json.dumps(answ), self.r_key))
msg = self.conn.recv(4096)
msg_name = "".join((str(now_date.year), str(now_date.month), str(now_date.day), str(now_time.hour),
str(now_time.minute), str(now_time.second)))
if not data["ToUsers"] == "$ALL_USERS$":
toUsers.append( data["ToUsers"] )
else:
toUsers = mdb.get_user_list(self.usr)
for toUsr in toUsers:
if not os.path.exists("data/" + toUsr):
os.makedirs("data/" + toUsr)
msgFile = open("".join(("data/", toUsr, "/", msg_name, ".bin")), 'wb')
msgFile.write(msg)
msgFile.close()
mdb.add_file(msg_name, 'msg', self.usr, toUsr, str(now_date), now_time_str)
Log().local(self.usr, "Message to " + toUsr + " sended.", LOG_INFO, mdb)
mdb.change_state(toUsr, "isMsg", 1)
sz = os.path.getsize("".join(("data/", toUsr, "/", msg_name, ".bin")))
sz = round(sz / 1024, 2)
mdb.stat(self.usr, "msg", str(sz), now_time_str, str(now_date))
answ["answ"] = "send-msg-ok"
self.conn.send( AES256_encode_msg(json.dumps(answ), self.r_key) )
"""
Upload backup message to server
"""
if self.cfg["MediaFire"]["enable"] == True:
from firecloud import MediaFire
fire = MediaFire()
fire.set_config(self.cfg)
fire.upload_msg("".join(("data/", toUsr, "/", msg_name, ".bin")))
return
"""
Create/Delete news log
"""
if data["type"] == "news":
if data["action"] == "create":
Log().local(self.usr, "".join(('Create news "', data["news-header"],'"')), LOG_INFO, mdb)
elif data["action"] == "delete":
Log().local(self.usr, "".join(('Delete news "', data["news-header"],'"')), LOG_INFO, mdb)
return
"""
Send files
"""
if data["type"] == "send-files":
self.conn.send(b'ok')
toUsr = data["ToUser"]
while True:
answ = AES256_decode_msg(self.conn.recv(1024), self.r_key)
answ = json.loads(answ)
if not answ["header"] == self.header:
return
if answ["type"] == "end-retrieve":
mdb.change_state(toUsr, "isFiles", 1)
break
if not os.path.exists("".join(("data/" + toUsr + "/files/"))):
os.makedirs("".join(("data/", toUsr, "/files/")))
self.conn.send(b'recieveing...')
fname = ""
if answ["type"] == "sf":
fname = answ["filename"]
index = 0
newfn = fname
while True:
if not os.path.exists("".join(("data/", toUsr, "/files/", newfn, ".bin"))):
fname = newfn
break
else:
newfn = fname
index += 1
fn = fname.split(".")
nm = fn[0] + "(" + str(index) + ")"
fe = fn[1]
newfn = nm + "." + fe
f = open("".join(("data/", toUsr, "/files/", fname, ".bin")), "wb")
while True:
data = self.conn.recv(4096)
l = len(data) - 5
try:
if data[l:] == b'[end]':
f.write(data[:l])
f.close()
lfiles = lfiles + fname + ","
sz = os.path.getsize("".join(("data/", toUsr, "/files/", fname, ".bin")))
sz = round(sz / 1024, 2)
mdb.stat(self.usr, "file", str(sz), now_time_str, str(now_date))
Log().local(self.usr, "Send file: " + fname + " to " + toUsr, LOG_INFO, mdb)
mdb.add_file(fname, "file", self.usr, toUsr, str(now_date), now_time_str)
self.conn.send("complete".encode('utf-8'))
break
except:
Log().local(self.usr, "Error while downloading files", LOG_CRITICAL, mdb)
f.write(data)
mdb.close()
self.conn.close()
def send_msg(wnd, msg, all, lUsrPwd, usr):
"""
Send message to remote tcp server
"""
answ = str
toUser = str
if msg == "":
QtGui.QMessageBox.warning(wnd, 'Complete', 'Введите сообщение!', QtGui.QMessageBox.Yes)
return
if (usr == "") and (not all):
"""
If message sending to single user and user not selected then fail
"""
QtGui.QMessageBox.warning(wnd, 'Complete', 'Выберите пользователя!', QtGui.QMessageBox.Yes)
return
mdb = MariaDB()
if not mdb.connect(wnd.MDBServer, wnd.MDBUser, wnd.MDBPasswd, wnd.MDBBase):
QtGui.QMessageBox.critical(wnd, 'Ошибка', 'Ошибка соединения с Базой Данных!', QtGui.QMessageBox.Yes)
return
if not all:
toUser = mdb.get_user_by_alias(usr)
mdb.close()
client = TcpClient()
if not client.connect(wnd.TCPServer, wnd.TCPPort, wnd.user, lUsrPwd):
QtGui.QMessageBox.critical(wnd, "Ошибка", "Ошибка соединения с сервером!", QtGui.QMessageBox.Yes)
return
if not all:
answ = client.send_message(toUser, msg)
else:
answ = client.send_message("$ALL_USERS$", msg)
client.close()
if answ == "[FAIL]":
QtGui.QMessageBox.critical(wnd, 'Ошибка', 'Ошибка передачи сообщения!', QtGui.QMessageBox.Yes)
client.close()
return
if answ == "[FAIL-LEN]":
QtGui.QMessageBox.critical(wnd, 'Ошибка', 'Сообщение слишком длинное!', QtGui.QMessageBox.Yes)
client.close()
return
if answ == "[FAIL-ACCESS]":
QtGui.QMessageBox.critical(wnd, 'Ошибка', 'У Вас нет прав на отправку всем пользователям!',
QtGui.QMessageBox.Yes)
client.close()
return
if answ == "[SEND-MSG-OK]":
mb = MessageBase()
if not all:
mb.save_message(usr, msg, False)
QtGui.QMessageBox.information(wnd, 'Complete', 'Сообщение отправлено!', QtGui.QMessageBox.Yes)
else:
mb.save_message("Всем", msg, False)
QtGui.QMessageBox.information(wnd, 'Complete', 'Сообщение отправлено всем пользователям!',
QtGui.QMessageBox.Yes)
def run(self):
toUser = str("")
self.client = TcpClient()
mdb = MariaDB()
if not mdb.connect(self._wnd.MDBServer, self._wnd.MDBUser, self._wnd.MDBPasswd, self._wnd.MDBBase):
self.err.emit('Ошибка соединения с Базой Данных!')
return
toUser = mdb.get_user_by_alias(self._toUsr)
mdb.close()
if not os.path.exists("".join((self._wnd.app_path, "sendfiles"))):
os.makedirs("".join((self._wnd.app_path,"sendfiles")))
self.connectionStart.emit()
if not self.client.connect(self._server, self._port, self._wnd.user, self._wnd.passwd):
print("fail connection")
self.err.emit("Ошибка соединения с сервером!")
return
exts = []
try:
exts = self.cfg.unzip_formats()
except:
Log().local("Error reading unzip formats")
c_exts = []
try:
c_exts = self.cfg.uncrypt_formats()
except:
Log().local("Error reading uncrypted formats")
print("start send")
self.client.begin_send_files(toUser)
for sfile in self.fileList:
lsf = sfile.split("/")
l = len(lsf)
fname = lsf[l - 1]
"""
Checking extension
"""
isCompress = True
isCrypt = True
tmp_fname = fname.split(".")
ext = tmp_fname[len(tmp_fname) - 1].lower()
for ex in exts:
if ex == ext:
isCompress = False
break
for ex in c_exts:
if ex == ext:
isCrypt = False
break
"""
Rename file
"""
while True:
try:
parts = fname.split("'")
fname = ""
l = len(parts)
i = 0
for part in parts:
i += 1
if i < l:
fname = fname + part + "_"
else:
fname = fname + part
break
except:
break
self.compressStart.emit(fname)
if isCompress:
if not zlib_compress_file(sfile, "".join((self._wnd.app_path, "sendfiles/", fname, ".z"))):
Log().local("Error compressing send file: " + fname)
print("error compressing")
self.client.close()
self.err.emit("Ошибка при сжатии файла")
return
else:
print("".join((fname, " compressed")))
else:
print(fname + " not compressed")
shutil.copy2(sfile, "sendfiles/" + fname + ".z")
if isCrypt:
self.cryptStart.emit(fname)
if not AES256_encode_file("".join((self._wnd.app_path, "sendfiles/", fname, ".z")),
"".join((self._wnd.app_path, "sendfiles/", fname, ".bin")),
self.a_key):
Log().local("Error encrypting send file: " + fname)
print("error crypting")
self.client.close()
self.err.emit("Ошибка при шифровании сообщения")
else:
print("".join((fname, " crypted")))
else:
print(fname + " not crypt")
shutil.copy2("".join((self._wnd.app_path,"sendfiles/", fname, ".z")),
"".join((self._wnd.app_path,"sendfiles/", fname, ".bin")))
self.sendStart.emit(fname)
self.client.send_file("".join((self._wnd.app_path, "sendfiles/", fname)))
self.sendFileComplete.emit()
try:
os.remove("".join((self._wnd.app_path, "sendfiles/", fname, ".z")))
os.remove("".join((self._wnd.app_path, "sendfiles/", fname, ".bin")))
except:
Log().local("Error filename")
self.err.emit("Ошибка в имени файла!")
self.client.end_send_files()
self.sendComplete.emit()
print("send complete")
self.client.close()
def run(self):
if self.task == "news":
con = sqlite3.connect(self.cur_path + 'news.db')
cur = con.cursor()
try:
cur.execute(
'CREATE TABLE news(id INTEGER PRIMARY KEY AUTOINCREMENT, title VARCHAR(512), date VARCHAR(20))')
con.commit()
except:
pass
mdb = MariaDB()
if not mdb.connect(self.configs["MDBServer"], self.configs["MDBUser"], self.configs["MDBPasswd"],
self.configs["MDBBase"]):
self.err.emit("Ошибка соединения с Базой Данной", self.task)
return
news_list = mdb.check_news()
l = len(news_list)
if l != self.news_count:
self.setNewsCount.emit(l)
self.clearNews.emit()
for news in news_list:
cur.execute(
"SELECT * FROM news WHERE title='" + news["title"] + "' and date='" + news["date"] + "'")
n_list = cur.fetchall()
if len(n_list) == 0:
cur.execute(
"INSERT INTO news(title, date) VALUES('" + news["title"] + "', '" + news["date"] + "')")
con.commit()
"""
Show tooltip
"""
if not mdb.is_admin(self.user):
self.showNewsBaloon.emit(news["date"], news["title"])
self.addInNews.emit(news["date"], news["title"])
mdb.close()
con.close()
self.checkNewsComplete.emit()
self.exit(0)
elif self.task == "msg_and_files":
"""
Checking server status (online/offline)
"""
client = TcpClient()
if not client.check_status(self.configs["TcpServer"], self.configs["TcpPort"]):
self.serverOffline.emit()
else:
self.serverOnline.emit()
client.close()
"""
Checking update, messages, files
"""
mdb = MariaDB()
if not mdb.connect(self.configs["MDBServer"], self.configs["MDBUser"], self.configs["MDBPasswd"],
self.configs["MDBBase"]):
self.err.emit("Ошибка соединения с Базой Данных!", self.task)
return
if mdb.check_update(self.user):
mdb.close()
print("Доступны обновления.")
self.updateAvailable.emit()
return
if mdb.check_files(self.user):
mdb.close()
print("Есть новые файлы.")
self.filesAvailable.emit()
return
if mdb.check_messages(self.user) and (not self.msg_status):
mdb.close()
print("Есть новые сообщения.")
self.msgAvailable.emit()
return
mdb.close()
self.nothingAvailable.emit()
return
def run(self):
mdb = MariaDB()
if not mdb.connect(self.configs["MDBServer"], self.configs["MDBUser"], self.configs["MDBPasswd"],
self.configs["MDBBase"]):
self.err.emit("Ошибка соединения с Базой Данных!", self.task)
return
if not mdb.is_admin(self.news["user"]):
self.err.emit("Нет прав на удаление новости!")
mdb.close()
return
else:
mdb.delete_news(self.news)
mdb.log(self.news["user"], "".join(("Удалил новость [", self.news["header"], "]")))
mdb.close()
con = sqlite3.connect("".join((self.cur_path, 'news.db')))
cur = con.cursor()
cur.execute("DELETE FROM news WHERE title='" + self.news["header"] + "' and date='" + self.news["date"] + "'")
con.commit()
con.close()
self.deleteComplete.emit()
