def __reset_state(self):
self.__xml_filename = None
self.__root = None
self.__employees = Employees()
self.__organization = Organization()
self.__errors = list()
self.__warnings = list()
def clear_data(self):
"""Обнуляет состояние модели"""
self.organization = Organization()
self.fill_organization_fields()
self.model = EmployeesListModel(Employees())
self.proxy_model.setSourceModel(self.model)
self.ui.employees_table.setModel(self.proxy_model)
self.update_delegates()
self.model.dataChanged.connect(self.data_changed)
self.model.rowsAddRemove.connect(self.data_changed)
self.model.selectHint.connect(self.select_cell)
self.auto_saver.update_data(self.organization, self.model.employees)
self.filename = None
self.data_is_saved = True
self.update_window_title()
class XLSXParser:
"""
Класс XLSXParser служит для импорта XLSX файлов.
"""
def __init__(self):
self.__xlsx_filename = None
self.__employees = Employees()
self.__errors = list()
self.__warnings = list()
def __reset_state(self):
self.__xlsx_filename = None
self.__employees = Employees()
self.__errors = list()
self.__warnings = list()
def get_employees(self):
return self.__employees
def get_errors(self):
return self.__errors
def get_warnings(self):
return self.__warnings
def load_file(self, filename):
"""Разбирает XLSX файл и заполняет данными список сотрудников"""
self.__reset_state()
# Пробуем открыть файл
try:
wb = load_workbook(filename)
first_sheet_name = wb.sheetnames[0]
ws = wb[first_sheet_name]
except OSError:
self.__errors.append('ERROR: XLSX файл по пути "' + filename +
'" не найден.')
return False
self.__xlsx_filename = filename
excel_employees = ws.rows
for excel_employee in excel_employees:
# Пропускаем шапку таблицы
if excel_employee[0].row == 1:
continue
employee = self.__employee_from_row(excel_employee)
self.__employees.add(employee)
return True
def __employee_from_row(self, excel_row):
new_employee = Employee()
employee_full_name = " ".join(
(str(excel_row[0].value), str(excel_row[1].value),
str(excel_row[2].value)))
for field in Employee.ALL_FIELDS:
field_id = Employee.ALL_FIELDS.index(field)
# Проверка форматов ячеек
if str(type(excel_row[field_id].value)) != str(type(None)):
if field == 'birth_date':
if str(type(excel_row[field_id].value)
) != "<class 'datetime.datetime'>":
self.__warnings.append(
"WARNING: Формат ячейки 'Дата рождения' сотрудника {} не является датой."
" Пожалуйста, проверьте формат ячейки. Она должа иметь формат 'Дата'."
.format(employee_full_name))
excel_row[field_id].value = None
elif field == 'experience':
if str(type(excel_row[field_id].value)) != "<class 'int'>":
self.__warnings.append(
"WARNING: Формат ячейки 'Стаж' сотрудника {} не является числом. "
"Пожалуйста, проверьте формат ячейки. Она должа иметь формат 'Числовой'."
.format(employee_full_name))
excel_row[field_id].value = ''
else:
if str(type(excel_row[field_id].value)) != "<class 'str'>":
self.__warnings.append(
"WARNING: Формат ячейки '{}' сотрудника {} не является текстовым. "
"Пожалуйста, проверьте формат ячейки. Она должа иметь формат 'Текст'."
.format(Employee.translate(field),
employee_full_name))
excel_row[field_id].value = ''
# аие полей сотрудника
if field in Employee.LIST_FIELDS:
if excel_row[field_id].value is None:
value = list()
else:
value = str(excel_row[field_id].value).split(',')
value = list(map(str.strip, value))
else:
value = '' if excel_row[field_id].value is None else excel_row[
field_id].value
if field in Employee.LIST_FIELDS:
new_employee[field] = value
elif field == 'birth_date':
if value != '':
value = value.strftime("%Y-%m-%d")
new_employee[field] = value
elif field == 'sex':
if value in ('Мужской', 'Женский', ''):
new_employee[field] = value
else:
self.__warnings.append(
"WARNING: Ячейка 'Пол' сотрудника {} заполнена неправильно. "
"Пожалуйста, проверьте текст ячейки. "
"Она должа содержать одно из двух значений: 'Мужской' или 'Женский'."
.format(employee_full_name))
new_employee[field] = ''
else:
new_employee[field] = str(value)
return new_employee
@staticmethod
def save_to_file(filename, employees):
"""Сохраняет данные в XLSX файл"""
try:
wb = load_workbook(
resource_path('./resources/template_excel.xlsx'))
first_sheet_name = wb.sheetnames[0]
ws = wb[first_sheet_name]
except OSError as e:
print(e)
return False
# Заполняем данные сотрудников
ws._current_row = 1 # Фикс бага в openpyxl, который не правильно считает текущую строку
for employee in employees.values():
xlsx_employee = XLSXParser.__employee_to_row(employee)
ws.append(xlsx_employee)
for row in ws.iter_rows(min_row=2):
XLSXParser.__apply_styles_to_row(row)
rd = ws.row_dimensions[row[0].row]
rd.height = 40
wb.save(filename=filename)
return True
@staticmethod
def __employee_to_row(employee):
xlsx_employee = list()
for field in Employee.ALL_FIELDS:
if field == 'birth_date':
birth_date = employee['birth_date']
birth_date = datetime.strptime(birth_date, "%Y-%m-%d")
# birth_date = birth_date.strftime("%d.%m.%Y")
xlsx_employee.append(birth_date)
elif field == 'experience':
experience = '' if employee['experience'] == '' else int(
employee['experience'])
xlsx_employee.append(experience)
elif field in Employee.LIST_FIELDS:
hazards = employee[field]
hazards_str = ', '.join(hazards)
xlsx_employee.append(hazards_str)
else:
value = employee[field]
xlsx_employee.append(value)
return xlsx_employee
@staticmethod
def __apply_styles_to_row(row):
border = Border(left=Side(border_style='thin'),
right=Side(border_style='thin'),
top=Side(border_style='thin'),
bottom=Side(border_style='thin'))
for cell in row:
cell.border = border
if cell.column in (4, 5, 7, 8):
alignment = Alignment(horizontal='center', vertical='center')
cell.alignment = alignment
else:
alignment = Alignment(horizontal='left',
vertical='top',
wrap_text=True)
cell.alignment = alignment
if cell.column == 5:
cell.number_format = 'DD.MM.YYYY'
elif cell.column == 7:
cell.number_format = '0'
def __reset_state(self):
self.__xlsx_filename = None
self.__employees = Employees()
self.__errors = list()
self.__warnings = list()
def __init__(self):
self.__xlsx_filename = None
self.__employees = Employees()
self.__errors = list()
self.__warnings = list()
class XMLParser:
"""
Класс XMLParser служит для работы c XML файлами (открытие файла, разбор данных и сохранение изменений).
"""
def __init__(self):
self.__xml_filename = None
self.__root = None
self.__employees = Employees()
self.__organization = Organization()
self.__errors = list()
self.__warnings = list()
def __reset_state(self):
self.__xml_filename = None
self.__root = None
self.__employees = Employees()
self.__organization = Organization()
self.__errors = list()
self.__warnings = list()
def get_organization(self):
return self.__organization
def get_employees(self):
return self.__employees
def get_errors(self):
return self.__errors
def load_file(self, filename):
"""Разбирает XML файл и заполняет данными список сотрудников и данные об организации"""
self.__reset_state()
# Пробуем открыть файл
try:
parser = etree.XMLParser(remove_blank_text=True)
tree = etree.ElementTree(file=filename, parser=parser)
except OSError:
self.__errors.append('ERROR: XML файл по пути "' + filename + '" не найден.')
return False
except etree.XMLSyntaxError:
self.__errors.append('ERROR: Не возможно разобрать файл "' + filename + '".')
return False
self.__xml_filename = filename
# Корень древа - register?
if tree.getroot().tag != 'register':
self.__errors.append('ERROR: Не обнаружен тег <register> в XML файле.')
return False
self.__root = tree.getroot()
# Режем хвосты у тегов и очищаем лишние пробелы (они могут помешать корректной работе парсера)
self.__clear_xml()
# Переносим содержимое тега <job> в <employee> для удобного парсинга
self.__soft_remove_job_tags()
# Заполняем модель данными
self.__fill_organization()
self.__fill_employees()
return True
@staticmethod
def save_to_file(filename, organization, employees):
"""Сохраняет данные в XML файл"""
root = etree.Element('register')
# Дата создания документа
date = etree.SubElement(root, 'date')
now = datetime.datetime.now()
date.text = now.strftime("%Y-%m-%d")
# Заполняем тег <organization>
organization_node = etree.SubElement(root, 'organization')
for field in Organization.ALL_FIELDS:
node = etree.SubElement(organization_node, field)
node.text = organization[field].strip()
# Заполняем данные сотрудников
for employee in employees.values():
employee_node = etree.SubElement(root, 'employee')
# Заполняем корневой тег <employee> сотрудника
for field in Employee.PERSON_FIELDS:
node = etree.SubElement(employee_node, field)
node.text = employee[field].strip()
# Заполняем тег <job> сотрудника
job_node = etree.SubElement(employee_node, 'job')
for field in Employee.JOB_FIELDS:
if field not in Employee.LIST_FIELDS:
node = etree.SubElement(job_node, field)
node.text = employee[field].strip()
else:
if len(employee[field]) > 0:
hazard_node = etree.SubElement(job_node, field)
for hazard in employee[field]:
code = etree.SubElement(hazard_node, 'code')
code.text = hazard.strip()
save_tree = etree.ElementTree(root)
save_tree.write(filename, pretty_print=True, encoding="utf-8", xml_declaration=True)
return True
def __fill_organization(self):
"""Заполняет информацией поля организации."""
organization = self.__root.find('organization')
# Если нет тега <organization>, то заполняем поля пустыми значениями.
if organization is None:
self.__warnings.append('WARNING: В XML файле отсутствует тег <organization>.')
for field in self.__organization.keys():
self.__organization[field] = ''
return
# Заполняем найденные поля значениями, а отсутствующие пустыми строками
for field in Organization.ALL_FIELDS:
try:
self.__organization[field] = organization.find(field).text
except AttributeError:
self.__organization[field] = ''
self.__warnings.append('WARNING: Не найден тег <' + field + '> в разделе <organization>.')
def __fill_employees(self):
"""Заполняет информацией поля сотрудника."""
employees_count = len(self.__root.findall('employee'))
# Если не найдены сотрудники в XML файле
if employees_count == 0:
self.__warnings.append('WARNING: В XML файле не обнаружен ни один сотрудник.')
return
# Перебираем найденных сотрудников
for i, xml_employee in enumerate(self.__root.iter("employee")):
# Создаем нового острудника и заполняем его поля
new_employee = Employee()
for field in Employee.ALL_FIELDS:
# Если поле не обнаружено
if xml_employee.find(field) is None:
self.__warnings.append('WARNING: У сотрудника {} (id:{}) не обнаружен тег <{}>'
.format(new_employee['full_name'], str(i), field))
# Если это не список, то просто записываем значение поля
elif field not in Employee.LIST_FIELDS:
new_employee[field] = xml_employee.find(field).text
# Если это список вредностей то перебираем его
else:
hazards_count = len(xml_employee.findall(field + '/code'))
# Если в списке нет вредносте, то пропускаем его
if hazards_count == 0:
continue
for hazard in xml_employee.iterfind(field + '/code'):
# Проверяем, что в теге вредности есть текст
if hazard.text is None:
self.__warnings.append('WARNING: Пустой тег <code> у сотрудника {} (id:{})'
.format(new_employee['full_name'], str(i)))
continue
# Если все в порядке, записываем вредность
new_employee[field].append(hazard.text)
self.__employees.add(new_employee)
def __soft_remove_job_tags(self):
"""Удаляет тег <job>, перенося его детей в его родителя - <employee>."""
# Перебираем найденных сотрудников
for xml_employee in self.__root.iter("employee"):
job = xml_employee.find('job')
# Если отсутствует тег <job> то переходим к следующему сотруднику
if job is None:
continue
for child in job:
xml_employee.append(child)
xml_employee.remove(job)
def __clear_xml(self):
"""Удаляет хвосты и лишние пробелы в тексте у всех элементов в xml файле,
так как наша схема не предполагает их наличие."""
for element in self.__root.iter("*"):
element.tail = None
if element.text is not None and not element.text.strip():
element.text = None
def validate(self):
self.__errors = list()
if self.__xml_filename is None:
self.__errors.append("ERROR: XML файл еще не загружен.")
return False
try:
schema_filename = resource_path('resources/xml_schema.xsd')
schema = etree.XMLSchema(file=schema_filename)
xml_file = etree.ElementTree(file=self.__xml_filename)
if not schema.validate(xml_file):
e = schema.error_log[0]
error_tag = "<{}>".format(e.path.split('/').pop())
error_path = "<{}>".format("> / <".join(e.path.lstrip('/').split('/')))
self.__errors.append("{}: Ошибка валидации XML файла!\n"
"Тег: {}\n"
"Путь: {}\n"
"Строка: {}".format(e.level_name, error_tag, error_path, e.line))
return False
return True
except etree.XMLSyntaxError as err:
self.__errors.append("ERROR: Ошибка разбора XML файла:{0}".format(err))
return False
except ValueError as err:
self.__errors.append("ERROR: Не правильный формат XML файла: {0}".format(err))
return False
except OSError:
self.__errors.append("ERROR: Ошибка чтения файла '{0}'".format(self.__xml_filename))
return False
def _log_tree(self):
"""Создает "отпечаток" текущего состояния данных. Использовать для отладки."""
tree = etree.ElementTree(self.__root)
tree.write('tests/xml_parser_data.xml', pretty_print=True, xml_declaration=True, encoding="utf-8")
def setUp(self):
self.employees = Employees()
class ClassTestEmployees(unittest.TestCase):
def setUp(self):
self.employees = Employees()
def test_creation(self):
self.assertEqual(len(self.employees), 0)
def test_adding_employees(self):
self.employees.add_empty_employee()
self.assertEqual(len(self.employees), 1)
def test_getting_employees(self):
self.employees.add_empty_employee()
employee = self.employees.get_employee(0)
with self.assertRaises(AttributeError):
employee.bla_bla_bla = 0
self.assertEqual(employee.patronymic, '')
self.assertIsInstance(employee.hazard_factors, list)
def test_edit_employee(self):
self.employees.add_empty_employee()
hazards = ['1', '2', '3']
employee = self.employees.get_employee(0)
employee.family_name = 'Иванов'
employee.first_name = 'Иван'
self.assertEqual(employee.full_name, 'Иванов Иван')
employee.patronymic = 'Иванович'
self.assertEqual(employee.family_name, 'Иванов')
self.assertEqual(employee.full_name, 'Иванов Иван Иванович')
employee.hazard_types = hazards
hazards.append('4')
new_patronymic = 'Сидорович'
employee.patronymic = new_patronymic
new_patronymic = 'Андреевич'
self.assertEqual(employee.full_name, 'Иванов Иван Сидорович')
self.assertEqual(len(employee.hazard_types), 3)
def test_clone_employee(self):
employee = self.employees.add_empty_employee()
employee.family_name = 'Иванов'
employee.first_name = 'Иван'
employee.patronymic = 'Иванович'
employee.hazard_types = ['1', '2', '3']
employee2 = employee.copy()
employee2.family_name = 'Петров'
employee2.hazard_types = ['4', '5', '6', '7']
self.assertEqual(employee.family_name, 'Иванов')
self.assertEqual(len(employee.hazard_types), 3)
self.assertEqual(employee2.family_name, 'Петров')
self.assertEqual(len(employee2.hazard_types), 4)
def remove_employee(self):
self.employees.add_empty_employee()
self.employees.add_empty_employee()
self.assertEqual(len(self.employees), 2)
self.employees.rem_employee(1)
self.assertEqual(len(self.employees), 1)
def __init__(self, list_len):
self.organization = Organization()
self.employees = Employees()
generic = Generic('ru')
ru = RussiaSpecProvider()
generic.add_provider(RussiaSpecProvider)
hazards = HazardsListsHelper()
hazard_types = list(hazards.get_hazard_types().keys())
hazard_factors = list(hazards.get_hazard_factors().keys())
for _ in range(0, list_len):
# Создаем нового сотрудника и выбираем ему случайный пол
employee = Employee()
gender = random.choice([Gender.FEMALE, Gender.MALE])
# Заполняем объект сотрудника данными
employee['family_name'] = generic.person.last_name(gender=gender)
employee['first_name'] = generic.person.name(gender=gender)
employee['patronymic'] = ru.patronymic(gender=gender)
employee['sex'] = "Мужской" if gender == Gender.MALE else "Женский"
birth_date = generic.datetime.date(start=1950, end=2000)
employee['birth_date'] = birth_date.strftime("%Y-%m-%d")
employee[
'address_free_form'] = "{}, г {}, {} {}, д {}, кв {}".format(
generic.address.region(), generic.address.city(),
generic.address.street_suffix(),
generic.address.street_name(), random.randint(1, 400),
random.randint(1, 400))
age = date.today().year - birth_date.year
employee['experience'] = str(random.randint(0, age - 18))
employee['specialty'] = generic.person.occupation()
hazard_types_copy = hazard_types.copy()
hazard_factors_copy = hazard_factors.copy()
employee_hazard_types = list()
employee_hazard_factors = list()
for i in range(0, random.randint(0, 5)):
employee_hazard_types.append(
hazard_types_copy.pop(
random.randint(0,
len(hazard_types_copy) - 1)))
for i in range(0, random.randint(0, 10)):
employee_hazard_factors.append(
hazard_factors_copy.pop(
random.randint(0,
len(hazard_factors_copy) - 1)))
employee['hazard_types'] = employee_hazard_types
employee['hazard_factors'] = employee_hazard_factors
# Добавляем острудника в список
self.employees.add(employee)
self.organization['org_name'] = '{} "{}"'.format(
generic.business.company_type(abbr=True),
generic.business.company())
self.organization['inn'] = str(random.randint(1000000000, 9999999999))
self.organization['ogrn'] = str(
random.randint(1000000000000, 9999999999999))
self.organization[
'org_address'] = "{}, {}, город {}, {} {}, дом {}".format(
generic.address.zip_code(), generic.address.region(),
generic.address.city(), generic.address.street_suffix(),
generic.address.street_name(), random.randint(1, 400))
gender = random.choice([Gender.FEMALE, Gender.MALE])
self.organization['head_full_name'] = "{} {} {}".format(
generic.person.last_name(gender=gender),
generic.person.name(gender=gender), ru.patronymic(gender=gender))
gender = random.choice([Gender.FEMALE, Gender.MALE])
self.organization['representative_full_name'] = "{} {} {}".format(
generic.person.last_name(gender=gender),
generic.person.name(gender=gender), ru.patronymic(gender=gender))
self.organization[
'representative_position'] = generic.person.occupation()
def __init__(self):
# Подключаем Представление
# flags = Qt.WindowFlags()
# flags = Qt.WindowFlags(Qt.Window)
# super(MWView, self).__init__(parent=None, flags=flags)
#
# # Подключаем UI
# self.ui = uic.loadUi(resource_path('./resources/main_window.ui'), self)
QMainWindow.__init__(self)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
self.model = EmployeesListModel(Employees())
self.organization = Organization()
self.auto_saver = AutoSaver(self.organization, self.model.employees)
self.filename = None
self.last_path = None
self.data_is_saved = True
self.app_settings = Settings()
# Стартовая инициализация внешнего вида / данных
self.update_window_title()
self.fill_organization_fields()
# Список чекбоксов для отображения/скрытия колонок таблицы
self.HIDE_COLUMN_CHECKBOXES = [
self.ui.hide_col_family_name, self.ui.hide_col_first_name,
self.ui.hide_col_patronymic, self.ui.hide_col_sex,
self.ui.hide_col_birth_date, self.ui.hide_col_address_free_form,
self.ui.hide_col_experience, self.ui.hide_col_specialty,
self.ui.hide_col_hazard_types, self.ui.hide_col_hazard_factors
]
# Подключаем модель к главной таблице
self.proxy_model = EmployeesSortModel()
self.proxy_model.setSourceModel(self.model)
self.ui.employees_table.setModel(self.proxy_model)
# Создаем делегатов для редактирования данных модели
self.in_line_edit_delegate = InLineEditDelegate(self, self.model)
self.gender_selection_delegate = GenderSelectionDelegate(self)
self.birth_date_selection_delegate = BirthDateSelectionDelegate(self)
self.experience_selection_delegate = ExperienceSelectionDelegate(self)
self.hazards_selection_delegate = HazardsSelectionDelegate(self)
# Подключаем их к таблице
self.update_delegates()
# Выравниваем колонки таблицы
self.adjust_column_width()
# Подключаем контекстное меню к таблице
self.ui.employees_table.setContextMenuPolicy(
QtCore.Qt.CustomContextMenu)
self.ui.employees_table.customContextMenuRequested.connect(
self.context_menu)
# Подключаем сигналы
self.ui.add_employee_btn.clicked.connect(self.proxy_model.insertRow)
self.ui.remove_employee_btn.clicked.connect(self.remove_rows)
self.ui.menu_about.triggered.connect(self.open_about_window)
self.ui.organization_edit_btn.clicked.connect(
self.organization_edit_btn_clicked)
self.ui.menu_new_file.triggered.connect(self.menu_new_file_clicked)
self.ui.menu_open.triggered.connect(self.menu_open_clicked)
self.ui.menu_import_excel.triggered.connect(self.menu_import_clicked)
self.ui.menu_auto_save.triggered.connect(self.menu_auto_save_clicked)
self.ui.menu_save.triggered.connect(self.menu_save_file_clicked)
self.ui.menu_save_as.triggered.connect(self.menu_save_file_as_clicked)
self.ui.menu_export_word.triggered.connect(
self.menu_export_word_clicked)
self.ui.menu_demo_list.triggered.connect(self.menu_demo_list_clicked)
self.ui.menu_demo_excel.triggered.connect(self.menu_demo_excel_clicked)
self.model.dataChanged.connect(self.data_changed)
self.model.rowsAddRemove.connect(self.data_changed)
self.model.selectHint.connect(self.select_cell)
# Горячие клавиши
QShortcut(QKeySequence(Qt.Key_F1), self, self.proxy_model.insertRow)
QShortcut(QKeySequence(Qt.Key_Delete), self, self.remove_rows)
QShortcut(QKeySequence.New, self, self.menu_new_file_clicked)
QShortcut(QKeySequence.Open, self, self.menu_open_clicked)
QShortcut(QKeySequence.Save, self, self.menu_save_file_clicked)
QShortcut(QKeySequence.SaveAs, self, self.menu_save_file_as_clicked)
# Подключаем сигналы к контроллеру
for column_name in Employee.ALL_FIELDS:
# Ищем чекбокс, отвечающий за колонку
hide_checkbox = getattr(self.ui, 'hide_col_' + column_name)
hide_checkbox.stateChanged.connect(self.hide_checkbox_clicked)
self.refresh_column_views()
self.showMaximized()