def __init__(self):
self.model = ProjectModel()
self.projectSelection = ProjectSelection()
self.newProjectDialog = NewProjectDialog()
self.project = None
self.__addEventHandlers()
self.__populateProjectList()
def add_project():
try:
request_data = request.data
request_data = json.loads(request_data)
except:
return jsonify({
"message": "Không thể lấy dữ liệu!",
"code": 412
}), 412
all_project_inserts = list()
if isinstance(request_data, dict):
request_data = [request_data]
for data in request_data:
all_project_inserts.append({
"Ten": data.get("ten"),
"MoTa": data.get("mota"),
"TrangThai": "Chưa được chọn",
"NguoiTao": data.get("nguoitao"),
"Loai": data.get("loai", ""),
"GhiChu": data.get("ghichu", ""),
"Cap": data.get("cap", ""),
"ChiDinh": data.get("chi_dinh"),
"ThoiGianTao": get_current_time(),
"ThoiGianCapNhat": get_current_time(),
})
if all_project_inserts:
try:
ProjectModel.insert_many_project(all_project_inserts)
except Exception as e:
print(e)
return jsonify({
"message": "Có lỗi phát sinh trong server!",
"code": 500
}), 500
return jsonify({"message": "Tạo đề tài thành công!", "code": 200}), 200
def get_by_project_teacher(teacher_id):
result = list()
id_std = request.args.get("id_std")
try:
ma_gv = TeacherModel.get_magvhd_by_id(teacher_id=teacher_id)
projects = ProjectModel.get_project_by_teacher(ma_gv)
cap = StudentModel.get_level_student_id(id_std)
except Exception as e:
print(e)
return jsonify({
"message": "Có lỗi phát sinh trong server!",
"code": 500
}), 500
for project in projects:
check = StudentModel.get_data_by_project(project.id)
if id_std and str(project.Cap) != str(cap):
continue
result.append({
"id": project.id,
"Ten": project.Ten,
"Mota": project.MoTa,
"TrangThai": project.TrangThai if not check else "Đã chọn",
"GhiChu": project.GhiChu,
"Cap": project.Cap
})
return jsonify({
"message": "request thành công!",
"data": result,
"code": 200
}), 200
def get_all_project():
result = list()
try:
projects = ProjectModel.get_all_project()
except Exception as e:
print(e)
return jsonify({
"message": "Có lỗi phát sinh trong server!",
"code": 500
}), 500
for project in projects:
check = StudentModel.get_data_by_project(project.id)
result.append({
"id": project.id,
"Ten": project.Ten,
"Mota": project.MoTa,
"TrangThai": project.TrangThai if not check else "Đã chọn",
"GhiChu": project.GhiChu,
"Cap": project.Cap
})
return jsonify({
"message": "request thành công!",
"data": result,
"code": 200
}), 200
def get_all_teacher_not_enough_student():
soluong = request.args.get("soluong", SoLuongSV.GVTiepNhan)
id_std = request.args.get("id_std")
try:
cap = StudentModel.get_level_student_id(student_id=id_std)
all_code_teachers = list()
all_project_teachers = ProjectModel.get_project_by_cap(cap)
for project in all_project_teachers:
all_code_teachers.append(project.ChiDinh)
teachers = TeacherModel.get_teacher_by_lt_soluong_tids(
soluong=soluong,
codes=all_code_teachers
)
except Exception as e:
return jsonify({"messgae": str(e), "code": 500}), 500
result = list()
for teacher in teachers:
data_teacher = {
"ten": teacher.Ten,
"soluong": teacher.SoLuong,
"magv": teacher.MaGV,
"email": teacher.Email
}
result.append(data_teacher)
return jsonify({"messgae": "Lấy thông tin thành công!", "code": 200, "data": result}), 200
def student_not_teacher():
result = list()
students = StudentModel.find_student_not_teacher()
for student in students:
detai = ""
if student.IDDeTai:
project = ProjectModel.get_project_by_id(
project_id=int(student.IDDeTai))
if project:
detai = project.Ten
data = {
"id": student.id,
"masv": student.MaSV,
"ten": student.Ten,
"lop": "12312312",
"hom_thu": "",
"trang_thai":
student.TrangThai if not student.IDDeTai else "DaChon",
"gvhd": student.MaGVHD,
"detai": detai,
"cap": student.Cap
}
result.append(data)
return jsonify({
"message": "Tạo ghi chú thành công!",
"data": result,
"code": 200
}), 200
def get_project_by_teacher():
ma_gvhd = request.args.get("ma_gvhd")
if not ma_gvhd:
return jsonify({"messgae": "Không tìm thấy mã giáo viên!", "code": 413}), 413
project_data_teachers = ProjectModel.get_project_by_one_teacher(ma_gvhd=ma_gvhd)
result = list()
for project_data_teacher in project_data_teachers:
data = {
"ten": project_data_teacher.Ten,
"mota": project_data_teacher.MoTa,
"trang_thai": project_data_teacher.Ten,
"Ten": project_data_teacher.Ten,
}
result.append(data)
if not result:
return jsonify({"message": "Không tìm thấy đề tài của giáo viên", "code": 201}), 201
return jsonify({"message": "Không tìm thấy đề tài của giáo viên", "data": result, "code": 200}), 200
def get_list_student_by_teacher(teacher_id):
result = list()
try:
ma_gvhd = TeacherModel.get_magvhd_by_id(teacher_id)
except:
return jsonify({"messgae": "Không tìm thấy mã giáo viên!", "code": 413}), 413
students = StudentModel.get_student_by_magvhd(magvhd=ma_gvhd)
for student in students:
project = None
if student.IDDeTai:
project = ProjectModel.get_project_by_id(student.IDDeTai)
data = {
"masv": student.MaSV,
"ten": student.Ten,
"id_sv": student.id,
"detai": project.Ten if project else "",
"ghichu": project.GhiChu if project else "",
"cap": student.Cap
}
result.append(data)
return jsonify({"messgae": "request thành công!", "data": result, "code": 200}), 200
def get_all_project():
result = list()
try:
projects = ProjectModel.get_all_project()
except Exception as e:
print(e)
return jsonify({
"message": "Có lỗi phát sinh trong server!",
"code": 500
}), 500
for project in projects:
result.append({
"id": project.id,
"Ten": project.Ten,
"Mota": project.MoTa,
"TrangThai": project.TrangThai,
"GhiChu": project.GhiChu
})
return jsonify({
"message": "request thành công!",
"data": result,
"code": 200
}), 200
def __init__(self):
self.tab = ProjectTab()
self.model = ProjectModel()
self.__addEventHandlers()
self.__populateProjectList()
class ProjectTabController:
def __init__(self):
self.tab = ProjectTab()
self.model = ProjectModel()
self.__addEventHandlers()
self.__populateProjectList()
def __populateProjectList(self):
for item in self.model.getProjectList():
self.tab.projectList.addItem(item.name)
def __addEventHandlers(self):
self.tab.browsePath.clicked.connect(lambda: self.__fileBrowser())
self.tab.searchBox.returnPressed.connect(lambda: self.__searchForItem())
self.tab.searchButton.clicked.connect(lambda: self.__searchForItem())
self.tab.addProjectButton.clicked.connect(lambda: self.__addProject())
self.tab.projectList.itemSelectionChanged.connect(lambda: self.__updateUI())
self.tab.saveButton.clicked.connect(lambda: self.__saveProject())
self.tab.deleteButton.clicked.connect(lambda: self.__deleteProject())
def __updateUI(self):
selectedItem = self.model.getSelectedProject(self.__getCurrentIndex())
self.tab.projectName.setText(selectedItem.name)
self.tab.projectDescription.setText(selectedItem.description)
self.tab.binPath.setText(selectedItem.binaryPath)
if selectedItem.hasBinaryAttributes():
self.tab.table.setItem(0, 1, QTableWidgetItem(selectedItem.binaryProperties['os']))
self.tab.table.setItem(1, 1, QTableWidgetItem(selectedItem.binaryProperties['arch']))
self.tab.table.setItem(2, 1, QTableWidgetItem(selectedItem.binaryProperties['machine']))
self.tab.table.setItem(3, 1, QTableWidgetItem("Win PE"))
self.tab.table.setItem(4, 1, QTableWidgetItem(selectedItem.binaryProperties['bits']))
self.tab.table.setItem(5, 1, QTableWidgetItem("Language"))
self.tab.table.setItem(6, 1, QTableWidgetItem(selectedItem.binaryProperties['canary']))
self.tab.table.setItem(7, 1, QTableWidgetItem(selectedItem.binaryProperties['crypto']))
self.tab.table.setItem(8, 1, QTableWidgetItem(selectedItem.binaryProperties['nx']))
self.tab.table.setItem(9, 1, QTableWidgetItem(selectedItem.binaryProperties['pic']))
self.tab.table.setItem(10, 1, QTableWidgetItem(selectedItem.binaryProperties['relocs']))
self.tab.table.setItem(11, 1, QTableWidgetItem("Relor"))
self.tab.table.setItem(12, 1, QTableWidgetItem(selectedItem.binaryProperties['stripped']))
def __populateTable(self):
selectedItem = self.model.getSelectedProject(self.__getCurrentIndex())
def __fileBrowser(self):
callback = QFileDialog.getOpenFileName()
if callback:
self.tab.binPath.setText(str(callback[0]))
def __searchForItem(self):
print("Search triggered")
def __getCurrentIndex(self):
i = self.tab.projectList.indexFromItem(self.tab.projectList.currentItem()).row()
return i
def __saveProject(self):
selectedItem = self.model.getSelectedProject(self.__getCurrentIndex())
selectedItem.name = self.tab.projectName.text()
selectedItem.description = self.tab.projectDescription.toPlainText()
selectedItem.binaryPath = self.tab.binPath.text()
self.model.checkAttributes(self.__getCurrentIndex())
self.__updateUI()
index = self.__getCurrentIndex()
self.tab.projectList.clear()
self.__populateProjectList()
self.tab.projectList.setCurrentRow(index)
def __deleteProject(self):
self.model.deleteProject(self.__getCurrentIndex())
self.tab.projectList.clear()
self.__populateProjectList()
def __addProject(self):
self.model.addProject()
self.tab.projectList.clear()
self.__populateProjectList()
def getCurrentProject(self):
return self.model.getSelectedProject(self.__getCurrentIndex())
def setup_class(self):
self.model = ProjectModel(FakeConnTool())
class TestProjectModel():
@classmethod
def setup_class(self):
self.model = ProjectModel(FakeConnTool())
@classmethod
def get_project_by_pid(self, pid):
pros, code = self.model.get_project_list()
for pro in pros['projects']:
if pro['id'] == pid:
return pro
@classmethod
def get_pid_by_name(self, name):
pros, code = self.model.get_project_list()
pid = None
for pro in pros['projects']:
if pro['name'] == name:
pid = pro['id']
break
return pid
def test_constructor(self):
assert self.model._db != None
assert self.model._uid == constant.TEST_UID
def test_get_project_list(self):
res = self.model.get_project_list()
expect = {
'projects': [{
'name': 'test_name3',
'owner': {
'name': 'abc',
'email': '*****@*****.**',
'uid': self.model._uid
},
'collaborator': [],
'repositories': {
'Github': [263537889]
},
'updated': '2021-01-02 08:19:51.374000+00:00',
'id': 'bv10AHp87ZtD93pPFfYh'
}, {
'name': 'test_name2',
'owner': {
'name': 'abc',
'email': '*****@*****.**',
'uid': self.model._uid
},
'collaborator': [],
'repositories': {
'Github': [182191121]
},
'updated': '2021-01-02 08:19:19.987000+00:00',
'id': 'hNR8NR81T98kPec31ryP'
}, {
'name': 'test_name',
'owner': {
'name': 'abc',
'email': '*****@*****.**',
'uid': self.model._uid
},
'collaborator': [],
'repositories': {
'Github': [324982851]
},
'updated': '2021-01-02 08:13:59.648000+00:00',
'id': constant.TEST_PID1
}, {
'name': 'test_name_compare',
'owner': {
'name': 'abc',
'email': '*****@*****.**',
'uid': self.model._uid
},
'collaborator': [],
'repositories': {
'Github': [325248132]
},
'updated': '2021-01-03 07:50:42.647000+00:00',
'id': 'testing_id_compare'
}]
}
assert res == (expect, 200)
def test_add_and_delete_project(self):
self.model.add_project('test_add_project')
pros, code = self.model.get_project_list()
expect = None
pid = None
for pro in pros['projects']:
if pro['name'] == 'test_add_project':
expect = pro
pid = pro['id']
assert expect != None
self.model.delete_project(self.get_pid_by_name('test_add_project'))
def test_when_name_exist_then_add_project_should_400(self):
self.model.add_project('test_add_repeat')
pros, code = self.model.add_project('test_add_repeat')
assert pros == None
assert code == status_code.BAD_REQUEST
self.model.delete_project(self.get_pid_by_name('test_add_repeat'))
def test_is_project_name_used(self):
assert self.model._ProjectModel__is_project_name_used(
'test_repeat_name') == False
self.model.add_project('test_repeat_name')
assert self.model._ProjectModel__is_project_name_used(
'test_repeat_name') == True
self.model.delete_project(self.get_pid_by_name('test_repeat_name'))
def test_delete_not_exist_project_should_404(self):
data, code = self.model.delete_project('no_such_pid')
assert data == None
assert code == status_code.NOT_FOUND
def test_is_project_owner(self):
project1 = {
'collaborator': [],
'name': 'test',
'owner': constant.TEST_UID,
'repositories': {
'Github': [21212121]
},
'updated': '2011-11-04 00:05:23.283000+00:00'
}
project2 = {
'collaborator': [],
'name': 'test',
'owner': 'other_guy',
'repositories': {
'Github': [21212121]
},
'updated': '2011-11-04 00:05:23.283000+00:00'
}
assert self.model._ProjectModel__is_project_owner(
project1, constant.TEST_UID) == True
assert self.model._ProjectModel__is_project_owner(
project2, constant.TEST_UID) == False
def test_update_name(self):
self.model.add_project('test_update_name')
pros, code = self.model.get_project_list()
pid = None
for pro in pros['projects']:
if pro['name'] == 'test_update_name':
expect = pro
pid = pro['id']
data, code = self.model.update_name(pid, 'updated')
update_pro = self.model._db.collection('projects').document(
pid).get().to_dict()
assert update_pro['name'] == 'updated'
self.model.delete_project(self.get_pid_by_name('test_update_name'))
self.model.delete_project(self.get_pid_by_name('updated'))
def test_update_name_no_name_parameter(self):
self.model.add_project('test_update_name_no_name')
pros, code = self.model.get_project_list()
pid = None
for pro in pros['projects']:
if pro['name'] == 'test_update_name_no_name':
expect = pro
pid = pro['id']
data, code = self.model.update_name(pid, '')
assert data == 'name is require'
assert code == status_code.BAD_REQUEST
self.model.delete_project(
self.get_pid_by_name('test_update_name_no_name'))
def test_update_name_no_such_pid(self):
self.model.add_project('test_update_name_wrong_pid')
data, code = self.model.update_name('wrong_pid', 'updated')
assert data == None
assert code == status_code.NOT_FOUND
self.model.delete_project(
self.get_pid_by_name('test_update_name_wrong_pid'))
def test_update_collaborator(self):
self.model.add_project('test_update_collaborator')
pid = self.get_pid_by_name('test_update_collaborator')
data, code = self.model.update_collaborator(pid,
'*****@*****.**',
'add')
update_pro = self.model._db.collection('projects').document(
pid).get().to_dict()
userModel = UserModel(FakeConnTool())
print(update_pro['collaborator'])
assert update_pro['collaborator'] == [
userModel.get_user_info_by_email('*****@*****.**')[0]['uid']
]
self.model.delete_project(
self.get_pid_by_name('test_update_collaborator'))
def test_remove_collaborator(self):
self.model.add_project('test_update_collaborator')
pros, code = self.model.get_project_list()
pid = None
for pro in pros['projects']:
if pro['name'] == 'test_update_collaborator':
expect = pro
pid = pro['id']
_, _ = self.model.update_collaborator(pid, '*****@*****.**',
'add')
data, code = self.model.update_collaborator(pid,
'*****@*****.**',
'remove')
assert ('移除成功！', status_code.OK) == (data['msg'], code)
self.model.delete_project(
self.get_pid_by_name('test_update_collaborator'))
def test_add_repo(self):
data = {'repositories': {'action': 'update', 'Github': [182191121]}}
self.model.add_project('test_add_repo')
pid = self.get_pid_by_name('test_add_repo')
self.model.update_repos(pid, data)
data, code = self.model.get_project_repos(pid)
assert ([182191121], status_code.OK) == ([data['repos'][0]['id']],
code)
self.model.delete_project(self.get_pid_by_name('test_add_repo'))
def test_remove_repo(self):
data = {'repositories': {'action': 'remove', 'Github': [182191121]}}
self.model.add_project('test_remove_repo')
pid = self.get_pid_by_name('test_remove_repo')
self.model.update_repos(pid, data)
data, code = self.model.get_project_repos(pid)
assert ([], status_code.OK) == (data['repos'], code)
self.model.delete_project(self.get_pid_by_name('test_remove_repo'))
def test_update_repo_with_erro_pid(self):
data = {'repositories': {'action': 'update', 'Github': [182191121]}}
self.model.add_project('test_add_repo')
pid = self.get_pid_by_name('test_add_repo')
self.model.update_repos(pid, data)
data, code = self.model.get_project_repos(pid)
assert ([182191121], status_code.OK) == ([data['repos'][0]['id']],
code)
self.model.delete_project(self.get_pid_by_name('test_add_repo'))
def test_get_project_setting(self):
data = {'repositories': {'action': 'remove', 'Github': [182191121]}}
self.model.add_project('test_get_project_setting')
pid = self.get_pid_by_name('test_get_project_setting')
data, code = self.model.get_project_setting(pid)
setting = Setting('test_get_project_setting', [],
UserModel(FakeConnTool())).to_dict()
assert (setting, status_code.OK) == (data, code)
self.model.delete_project(self.get_pid_by_name('test_remove_repo'))
def get_list_student():
result = list()
param = request.args
ten = param.get("ten")
ma_sv = param.get("masv")
lop = param.get("lop")
trang_thai = param.get("trang_thai")
gvhd = param.get("gvhd")
page = param.get("page", 1)
per_page = param.get("per_page", 10)
where = ""
if ten:
if not where:
where = "( StudentModel.Ten.contains(ten) )"
else:
where += " & ( StudentModel.Ten.contains(ten) )"
if ma_sv:
if not where:
where = "( StudentModel.MaSV.contains(ma_sv) )"
else:
where += " & ( StudentModel.MaSV.contains(ma_sv) )"
if gvhd:
if not where:
where = "( StudentModel.MaGVHD.contains(gvhd) )"
else:
where += " & ( StudentModel.MaGVHD.contains(gvhd) )"
result = list()
paging = dict()
if where:
where = eval(where)
tong = StudentModel.count_student_by_where(where)
if tong == 0:
return jsonify({
"messgae": "request thành công!",
"data": result,
"code": 200
}), 200
if page == -1:
students = StudentModel.get_all_student(where=where, is_full=True)
else:
paging = StudentController.generate_paging(page=page,
per_page=per_page,
sum_page=tong)
skip = per_page * (page - 1)
limit = per_page
students = StudentModel.get_all_student(where=where,
skip=skip,
limit=limit)
for student in students:
detai = ""
if student.IDDeTai:
project = ProjectModel.get_project_by_id(
project_id=int(student.IDDeTai))
if project:
detai = project.Ten
data = {
"id": student.id,
"masv": student.MaSV,
"ten": student.Ten,
"lop": "12312312",
"hom_thu": "",
"trang_thai":
student.TrangThai if not student.IDDeTai else "DaChon",
"gvhd": student.MaGVHD,
"detai": detai,
"cap": student.Cap
}
result.append(data)
return jsonify({
"message": "Tạo ghi chú thành công!",
"data": result,
"paging": paging,
"code": 200
}), 200
class ProjectController:
def __init__(self):
self.model = ProjectModel()
self.projectSelection = ProjectSelection()
self.newProjectDialog = NewProjectDialog()
self.project = None
self.__addEventHandlers()
self.__populateProjectList()
def __populateProjectList(self):
self.projectSelection.projectsList.clear()
projects = self.model.getProjectList()
for key in projects.keys():
i = QListWidgetItem(key)
j = ProjectWidget(projects[key])
i.setSizeHint(j.sizeHint())
self.projectSelection.projectsList.addItem(i)
self.projectSelection.projectsList.setItemWidget(i, j)
def __addEventHandlers(self):
self.newProjectDialog.createButton.clicked.connect(
lambda: self.__saveProject())
self.projectSelection.deleteProject.clicked.connect(
lambda: self.__deleteProject())
self.projectSelection.addProject.clicked.connect(
lambda: self.__addProject())
self.projectSelection.openProject.clicked.connect(
lambda: self.__openProject())
def __projectProperties(self):
self.project = self.newProjectDialog.newItem
self.newProjectDialog.binPath.setText(self.project.binaryPath)
self.newProjectDialog.table.setItem(
0, 1, QTableWidgetItem(self.project.binaryProperties['os']))
self.newProjectDialog.table.setItem(
1, 1, QTableWidgetItem(self.project.binaryProperties['arch']))
self.newProjectDialog.table.setItem(
2, 1, QTableWidgetItem(self.project.binaryProperties['machine']))
self.newProjectDialog.table.setItem(
3, 1, QTableWidgetItem(self.project.binaryProperties['class']))
self.newProjectDialog.table.setItem(
4, 1, QTableWidgetItem(self.project.binaryProperties['bits']))
self.newProjectDialog.table.setItem(
5, 1, QTableWidgetItem(self.project.binaryProperties['lang']))
self.newProjectDialog.table.setItem(
6, 1, QTableWidgetItem(self.project.binaryProperties['canary']))
self.newProjectDialog.table.setItem(
7, 1, QTableWidgetItem(self.project.binaryProperties['crypto']))
self.newProjectDialog.table.setItem(
8, 1, QTableWidgetItem(self.project.binaryProperties['nx']))
self.newProjectDialog.table.setItem(
9, 1, QTableWidgetItem(self.project.binaryProperties['pic']))
self.newProjectDialog.table.setItem(
10, 1, QTableWidgetItem(self.project.binaryProperties['relocs']))
self.newProjectDialog.table.setItem(
11, 1, QTableWidgetItem(self.project.binaryProperties['relro']))
self.newProjectDialog.table.setItem(
12, 1, QTableWidgetItem(self.project.binaryProperties['stripped']))
def __fileBrowser(self):
callback = QFileDialog.getOpenFileName()
if callback:
self.newProjectDialog.binPath.setText(str(callback[0]))
def __searchForItem(self):
searchText = self.tab.searchBox.text().lower()
# When search is triggered with an empty string clear the list
if searchText is "":
self.tab.projectList.clear()
self.__populateProjectList()
else:
# get all the items with substring of searched string
searches = []
for projectName in self.model.getProjectList().keys():
if searchText in projectName.lower():
searches.append(projectName)
# add those items with substring into the list
self.tab.projectList.clear()
for s in searches:
self.tab.projectList.addItem(s)
def __getCurrentIndex(self):
try:
return self.projectSelection.projectsList.currentItem().text()
except AttributeError:
return self.project.name
def __saveProject(self):
if self.newProjectDialog.projectName.text():
self.newProjectDialog.newItem.name = self.newProjectDialog.projectName.text(
)
self.project = self.model.saveProject(
self.newProjectDialog.newItem)
self.__populateProjectList()
self.__clear()
self.newProjectDialog.close()
def __deleteProject(self):
if not self.projectSelection.projectsList.selectedItems():
return
buttonReply = QMessageBox.question(
self.projectSelection, 'Delete Project',
"Are you sure you want to delete this project?",
QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
if buttonReply == QMessageBox.Yes:
self.model.deleteProject(self.__getCurrentIndex())
self.projectSelection.projectsList.clear()
self.__populateProjectList()
def __addProject(self):
path, response = QFileDialog.getOpenFileName(self.projectSelection)
try:
if response:
self.newProjectDialog.newItem = self.model.verifyBinary(path)
self.__projectProperties()
self.newProjectDialog.exec_()
self.__openProject()
except TypeError:
errorDialog = QtWidgets.QMessageBox()
errorDialog.setText('Unsupported File')
errorDialog.setWindowTitle("Error")
errorDialog.setInformativeText(
"The selected file is not ELF x86 or PE x86")
errorDialog.setIcon(3)
errorDialog.exec_()
def getCurrentProject(self):
return self.project
def __openProject(self):
if self.projectSelection.projectsList.selectedItems():
self.project = self.model.getSelectedProject(
self.__getCurrentIndex())
self.projectSelection.close()
else:
self.project = None
def __clear(self):
self.newProjectDialog.projectName.clear()
self.newProjectDialog.binPath.clear()
for i in range(12):
self.newProjectDialog.table.setItem(i, 1, QTableWidgetItem(''))
