def auction_cancel(auction):
"""Функция отмены процедуры"""
auction_info = found_procedure_223_db(auction, get_id=True)
print('БД процедуры: %s' % auction_info['db'])
if input('Установить процедуре статус "Прием заявок"? Y/n: ') in 'YН':
cn = Mc(connection=auction_info['connection'])
cn.execute_query(procedure_published_update_query % auction_info['id'])
cn.execute_query(lot_published_update_query % auction_info['id'])
print('''Установлен статус "Прием заявок"''')
xml_file, find_error = new_223_auction_cancel_finder(auction, out_dir)
if find_error:
print(find_error)
if input('Продолжить? Y/n: ') not in 'YН':
return 1
correction_status, correction_error = new_223_xml_corrector(xml_file)
if correction_status:
print('Пакет валиден')
else:
print('Пакет не валиден: ', correction_error)
if input('Опубликовать отмену аукциона? Y/n: ') not in 'YН':
return 1
imp_status, imp_info = new_223_import_xml(xml_file, auction_info['db'])
if imp_status:
print(imp_info)
return 0
else:
print('Пакет импортирован с ошибкой: %s' % imp_info)
return 1
def procedure_archiving(procedure_number):
global DATA_PROCESSED
# инициализация sql подключений
db_info = found_procedure_223_db(procedure_number)
if not db_info:
print('Процедура %(procedure_number)s не найдена' % vars())
return
cn = Mc(connection=db_info['connection'])
is_smsp = db_info['db'] in [
'223smsp_ea', '223smsp_ek', '223smsp_zk', '223smsp_zp'
]
print('Обработка %(procedure_number)s начата' % vars())
print(db_info['name'])
# проверяем, существует ли уже архив для данной процедуры
archive_procedures_list = [
archive[0:11] for archive in listdir(work_dir)
if archive.endswith('.zip') and isfile(join(work_dir, archive))
]
if procedure_number in archive_procedures_list:
print('Архив %(procedure_number)s.zip уже существует' % vars())
return 0
# создаем директорию процедуры и делаем ее рабочей директорией
chdir(work_dir)
create_dir(procedure_number)
chdir(procedure_number)
work_procedures_dir = join(work_dir, procedure_number)
# Здесь будем хранить основной массив данных
all_data = []
print('- Получение данных')
# обрабатываем заявки
chdir(work_procedures_dir)
with cn.open():
requests_data = cn.execute_query(get_requests_data_query % vars())
requests_data = found_location_dir(is_smsp, requests_data, 5)
# находим для каждого файла составляющие пути, куда будем класть данный файл в архив
# собираем их в лист allData
for data in requests_data:
archive_location_dir_parts = [
str(data[1]), requests_dir,
str(data[2]),
str(data[3])
]
# uri, links_list, name
request_data = [data[5], archive_location_dir_parts, str(data[4])]
all_data.append(request_data)
# обрабатываем протоколы
chdir(work_procedures_dir)
with cn.open():
protocols_data = cn.execute_query(get_protocols_data_query % vars())
protocols_data = found_location_dir(is_smsp, protocols_data, 4)
# находим для каждого файла составляющие пути, куда будем класть данный файл в архив
# собираем их в лист allData
for data in protocols_data:
archive_location_dir_parts = [
str(data[1]), protocols_dir,
str(data[2])
]
# uri, links_list, name
protocol_data = [data[4], archive_location_dir_parts, str(data[3])]
all_data.append(protocol_data)
# обрабатываем фичи
chdir(work_procedures_dir)
with cn.open():
features_data = cn.execute_query(get_features_data_query % vars())
features_data = found_location_dir(is_smsp, features_data, 5)
# находим для каждого файла составляющие пути, куда будем класть данный файл в архив
# собираем их в лист allData
for data in features_data:
archive_location_dir_parts = [
str(data[1]), requests_dir,
str(data[2]), features_dir,
str(data[3])
]
# uri, links_list, name
feature_data = [data[5], archive_location_dir_parts, str(data[4])]
all_data.append(feature_data)
# если установлен флаг organisations, то добавляем в архив сведения об организации
if namespace.organisation:
# обрабатываем сведения о файлах организации
chdir(work_procedures_dir)
with cn.open():
organisation_data = cn.execute_query(get_organisation_data_query %
vars())
organisation_data = found_location_dir(is_smsp, organisation_data, 5)
# находим для каждого файла составляющие пути, куда будем класть данный файл в архив
# собираем их в лист allData
for data in organisation_data:
archive_location_dir_parts = [
str(data[2]), requests_dir,
str(data[3]), organisation_data_dir,
str(data[1])
]
# uri, links_list, name
organisation_data = [
data[5], archive_location_dir_parts,
str(data[4])
]
all_data.append(organisation_data)
# переименование директорий в соответствии со словарем dirNamesDict
# замена обычных и фигурных скобок из-за проблем с re
for data in all_data:
renamed_dirs = []
for location in data[1]:
if location in dir_names_dict.keys():
location = dir_names_dict[location]
renamed_dirs.append(location)
data[1] = renamed_dirs
data[2] = re.sub(r'(\(|\)|\[|\])', '_', data[2])
# собираем excel файл с ценовыми предложениями (если они есть)
if db_info['db'] not in [
'223smsp_ea', '223smsp_ek', '223smsp_zk', '223smsp_zp'
]:
with cn.open():
offers_data = list(cn.execute_query(get_offers_data_query %
vars()))
if offers_data:
offer_top = get_query_top(get_offers_data_query % vars())
excel_file = Excel()
excel_list = excel_file.create_list(
sheet_name='Ценовые предложения')
excel_list.set_numeral(6)
excel_list.write_data_from_iter(offers_data, offer_top)
excel_list.set_default_column_width(150)
excel_file.save_file(save_dir=work_procedures_dir,
file_name='Ценовые предложения участников ' +
procedure_number)
# вычленяем из allData листы с директориями для формирования пути
archive_locations = [
archiveLocationDirParts[1] for archiveLocationDirParts in all_data
]
# создаем все необходимые нам директории
for location in archive_locations:
chdir(work_procedures_dir)
for directory in location:
directory = str(directory)
create_dir(directory)
chdir(directory)
# формируем путь и добавляем его в archiveLocationsFromAndTo вместе с путем источника
archive_locations_from_and_to = []
for archive_location_dir_parts in all_data:
archive_location_dir = join(*([work_procedures_dir] +
archive_location_dir_parts[1] +
[archive_location_dir_parts[2]]))
archive_locations_from_and_to.append([
normpath(archive_location_dir_parts[0]),
normpath(archive_location_dir)
])
print('- Копирование файлов')
# копируем файлы по директориям
chdir(work_procedures_dir)
for from_location, to_location in archive_locations_from_and_to:
# если возникла ошибка OSError: [Errno 36] File name too long
try:
copyfile(from_location, to_location)
except OSError as exc:
if exc.errno == 36:
to_location = get_rand_name(to_location)
copyfile(from_location, to_location)
else:
raise # re-raise previously caught exception
# архивируем директорию и удаляем ее
print('- Создание архива')
chdir(work_dir)
archive = make_archive(procedure_number, 'zip', work_procedures_dir)
print('- Удаление временных файлов')
rmtree(work_procedures_dir)
archive_byte_size = getsize(archive)
archive_MB_size = round(archive_byte_size / 1024 / 1024, 2)
DATA_PROCESSED += archive_byte_size
print('Создан архив: %(archive)s' % vars())
print('Размер архива: %(archive_MB_size)s МБ' % vars())
print('Обработка %(procedure_number)s завершена' % vars())
return archive
print(PROGNAME, VERSION, '\n', DESCRIPTION, '\nAuthor:', AUTHOR,
'\nRelease date:', RELEASE_DATE)
if __name__ == '__main__':
try:
# парсим аргументы командной строки
my_parser = create_parser()
namespace = my_parser.parse_args()
# вывод версии
if namespace.version:
show_version()
s_exit(OK)
cn = Mc(connection=Mc.MS_44_1_CONNECT).connect()
requests_info = cn.execute_query(get_requests_info_query, dicted=True)
for request_info in requests_info:
additional_information = json.loads(
request_info['additional_information'])
additional_information['status'] = int(
additional_information['status'])
additional_information[
'status_description'] = additional_information.get(
'status_description', '')
# если статус 0, то просто ответ, в сраку его
if additional_information['status'] == 0:
continue
@set_critical
@out_printer
@only_if_trade_record_exists
def check_pid_t(auction_data):
"""Проверка установки pid за час до торгов"""
if datetime.now() + timedelta(hours=-1) > auction_data[
't_start_trade_datetime'] and not auction_data['t_pid']:
auction_data['error'] = \
'не установлен pid за час до торгов' % auction_data
return auction_data
if __name__ == '__main__':
try:
# инициализируем подключения
cn_procedures = Mc(connection=PROCEDURE_223_TYPES[namespace.type]
['connection']).connect()
cn_catalog = Mc(connection=Mc.MS_223_CATALOG_CONNECT).connect()
cn_trade = Mc(connection=PROCEDURE_223_TYPES[namespace.type]
['connection_trade']).connect()
if namespace.auction:
all_published_procedures_info = cn_procedures.execute_query(
get_one_trade_awaiting_procedures_info_query %
namespace.auction,
dicted=True)
else:
all_published_procedures_info = cn_procedures.execute_query(
get_all_trade_awaiting_procedures_info_query, dicted=True)
# если поиск по базе с текущими условиями ничего не дал, то указываем, что ничего не нашлось
if namespace.auction and not all_published_procedures_info:
def get_available_connections():
"""Функция получения доступных подключений mysql"""
m = Mc()
return sorted([cn for cn in m.__dir__() if cn.startswith('MS')])
show_nagios_nm(data_file)
s_exit(OK)
# если указан запрос, то выполняем его
if namespace.query:
check_arguments(('nagios_name', 'connection'))
last_update_datetime = get_datetime(data_file, nagios_name)
query = re.sub(date_sub_string, '\'' + last_update_datetime + '\'',
get_query(query))
connection = get_connection(connection)
# получаем данные по запросу
mc = Mc(connection=connection)
with mc.open():
query_data = mc.execute_query(query)
# преобразовываем все данные в строки
out_info = tuple(
map(lambda x: [str(line) for line in x], query_data))
# если
if out_info:
out_info_len = len(out_info)
print(error_text % out_info_len)
for info_line in out_info:
print(
translit(str(data_separator.join(info_line)),
wait_install_crl_dir))
for location in bad_crl_dir, actual_crl_dir, old_crl_dir, tmp_crl_dir, wait_install_crl_dir:
if not exists(location):
mkdir(location)
# перед запуском удаляем содержимое tmp_crl_dir, wait_install_crl_dir
for location in tmp_crl_dir, wait_install_crl_dir:
for f in [
join(location, file) for file in listdir(location)
if file.endswith('.crl')
]:
remove(f)
# подключаемся к базе сертификатов
cn_crl = Mc(connection=Mc.MS_CERT_INFO_CONNECT)
# основной рабочий цикл
while True:
cn_crl.connect()
# получаем сведения о crl из последней версии файла
accredited_crl_info = cn_crl.execute_query(
get_accredited_crl_info_query, dicted=True)
# загружаем crl в неfсколько потоков
pool = ThreadPool(download_threads_count)
pool.map(get_crl_file, accredited_crl_info)
pool.close()
pool.join()
# проверяем каждый скачанный crl на необходимость установки и добавляем его в crl_for_update
def main():
# инициализируем счетчик записей
counter = count(start=1, step=1)
# инициализируем подключение к ftp
connect = Ftp(connection=Ftp.CONNECT_223_FREE_FTP)
# инициализируем подключения к бд
cn_catalog = Mc(connection=Mc.MS_223_CATALOG_CONNECT)
# искать будем за вчерашний день
YESTERDAY = (datetime.now() - timedelta(days=1)).__format__('%Y%m%d')
MAIL_TEXT = ''
# в этот временный файл мы будем писать загруженные архивы
tmp_zip = join(tmp_dir, zip_file)
connect.open()
# сюда мы запишем все локальные пути до xml, которые нам подошли
files_for_send = []
for search_dir in search_dirs:
# собираем содержимое всех указанных директорий (внутри они разбиты по регионам, нам нужно обойти все)
archive_dirs = [
region_dir + search_dir
for region_dir in connect.nlst(all_data_dir)
]
# получим полные пути до всех архивов за вчерашний день и зачем то упорядочим
# просто потому что все должно быть красиво)
all_new_archives = []
for archive_dir in archive_dirs:
region_files = sorted(connect.nlst(archive_dir),
key=lambda k: k,
reverse=True)
region_files = filter(lambda k: re.findall(YESTERDAY, k),
region_files)
for file in region_files:
all_new_archives.append(file)
# поочередно скачиваем архивы
for archive in all_new_archives:
connect.get(tmp_zip, archive)
# распакуем архив, а его самого удалим
shutil.unpack_archive(tmp_zip, tmp_dir)
os.remove(tmp_zip)
# обрабатываем каждую xml, которая распаковалась в директорию
for xml_file in os.listdir(tmp_dir):
file_r = join(tmp_dir + xml_file)
with open(file_r, mode='r', encoding='utf8') as xml:
XML = xml.read()
# находим условия, которые будем проверять
OUR_PLACE = re.findall(
r'<electronicPlaceId>(104|2580|3)</electronicPlaceId>',
XML)
# если для нашей площадки и метод не от старой секции, то забираем xml
if OUR_PLACE:
auction = re.findall(
r'<ns2:registrationNumber>(.*?)</ns2:registrationNumber>',
XML)[0]
version = re.findall(r'<ns2:version>(.*?)</ns2:version>',
XML)[0]
method_name = re.findall(
r'<ns2:purchaseCodeName>(.*?)</ns2:purchaseCodeName>',
XML)[0]
method_code = re.findall(
r'<ns2:purchaseMethodCode>(.*?)</ns2:purchaseMethodCode>',
XML)[0]
number = str(next(counter))
publication_info = found_procedure_223_db(auction,
version=version)
with cn_catalog.open():
ON_CATALOG = cn_catalog.execute_query(
check_catalog_query % (auction, version))
if publication_info:
MAIL_TEXT += '%s) %s версия %s (%s, код %s): опубликован как %s' % (
number, auction, version, method_name, method_code,
publication_info['name'])
else:
MAIL_TEXT += '%s) %s версия %s (%s, код %s): не опубликован на площадке' % (
number, auction, version, method_name, method_code)
if ON_CATALOG:
MAIL_TEXT += ', в каталоге присутствует\n\n'
else:
MAIL_TEXT += ', в каталоге отсутствует\n\n'
xml_with_link = join(
found_xml_dir,
number + '_' + auction + '_' + version + '.xml')
files_for_send.append(xml_with_link)
shutil.copyfile(file_r, xml_with_link)
os.remove(file_r)
XML_COUNT = len(files_for_send)
MAIL_THEME = 'Отчет по новым извещениям 223'
if XML_COUNT:
MAIL_TEXT = 'Найдены новые извещения (во вложении)\n\n' + MAIL_TEXT
else:
MAIL_TEXT = 'Новые извещения отсутствуют'
connect.close()
email.mail_sender(MAIL_THEME,
MAIL_TEXT,
recipients=recipients,
add_files=files_for_send,
report=True,
counter=XML_COUNT,
datetime=True)
if __name__ == '__main__':
# парсим аргументы командной строки
my_parser = create_parser()
namespace = my_parser.parse_args()
# если указано version, то выводим ее и выходим
if namespace.version:
show_version()
exit(0)
# если указан сервер, то запускаем как сервис
if namespace.server:
cn_cert = Mc(connection=Mc.MS_CERT_INFO_CONNECT)
try:
# инициируем лог-файл
log_file = join(normpath(log_dir),
log_name_mask % namespace.server)
init_log_config(log_file)
logger_name = 'SERVER_%s' % namespace.server
logger = logger(logger_name)
logger.info('Starting (server %s, waiting %s)' %
(namespace.server, sleep_time))
# основной цикл
while True:
# загружаем данные об установленных сертификатах
wait_install_crl_dir))
for location in bad_crl_dir, actual_crl_dir, old_crl_dir, tmp_crl_dir, wait_install_crl_dir:
if not exists(location):
mkdir(location)
# перед запуском удаляем содержимое tmp_crl_dir, wait_install_crl_dir
for location in tmp_crl_dir, wait_install_crl_dir:
for f in [
join(location, file) for file in listdir(location)
if file.endswith('.crl')
]:
remove(f)
# подключаемся к базе сертификатов
cn_crl = Mc(connection=Mc.MS_CERT_INFO_CONNECT)
cn_crl.connect()
# основной рабочий цикл
while True:
# получаем сведения о crl из бд
manual_crl_info = cn_crl.execute_query(
get_manual_crl_info_query, dicted=True)
# загружаем crl в несколько потоков
pool = ThreadPool(download_threads_count)
pool.map(get_crl_file, manual_crl_info)
pool.close()
pool.join()
# проверяем каждый скачанный crl на необходимость установки и добавляем его в crl_for_update