def check_plugins_versions(self) -> None:
""" Проверка версий плагинов
Проверка версий плагинов из списка
Обращение к WS с запросом версии плагина с помощью метода ws plugin_info:GetInfo
Возможно два режима проверки: server и client.
Режим server - проверка версии плагинов на сервере
Режим client - проверка версии плагинов на клиенте
"""
# ----------------------------------------
# ПРОВЕРКА ВХОДНЫХ ДАННЫХ
tools.check_keys_exist(self._input_data, ["plugins"], 'input_data', True, self._statistic)
tools.check_types(["plugins"], [self._input_data["plugins"]], [list], self._statistic)
tools.check_values(["len(plugins)"], [len(self._input_data["plugins"])], [0], ["!="], self._statistic)
tools.check_keys_exist(self._input_data, ["mode"], 'input_data', True, self._statistic)
tools.check_types(["mode"], [self._input_data["mode"]], [str], self._statistic)
tools.check_values(["mode"], [self._input_data["mode"]], [""], ["!="], self._statistic)
key_names = ['module_name', 'rel_path']
for plugin in self._input_data["plugins"]:
tools.check_keys_exist(plugin, key_names, "plugin", True, self._statistic)
tools.check_types(key_names, [plugin[key_names[0]], plugin[key_names[1]]], [str, str], self._statistic)
tools.check_values(key_names, [plugin[key_names[0]], plugin[key_names[1]]], ["", ""], ["!=", "!="],
self._statistic)
# ----------------------------------------
if self._input_data["mode"] == "server":
ws_client = SoapClient(self._server_ip, self._server_port, self._config, self._statistic)
elif self._input_data["mode"] == "client":
ws_client = SoapClient(self._client_ip, self._client_port, self._config, self._statistic)
else:
self._statistic.append_error("Недопустимое значение ключа 'mode'. Доступны: client, server",
"ОШИБКА КЛЮЧА JSON", True)
token = ws_users.server_login(ws_client, self._login, self._password, self._statistic)
for plugin in self._input_data["plugins"]:
result: dict = ws_common.get_plugin_info(ws_client, token, plugin['rel_path'], plugin['module_name'],
self._statistic)
if result['version'] == "not found module version !":
self._statistic.append_error(plugin['module_name'], "ОШИБКА ВЕРСИИ МОДУЛЯ")
if plugin['rel_path'] == "bad rel_path !":
self._statistic.append_warn("Модуль " + plugin['module_name'] + " " + plugin['rel_path'],
"НЕКОРРЕКТНЫЙ ПУТЬ")
module_info: str = "Version: " + result['version'] + "\n" + "User: "******"\n" + "Build: " + \
result['build'] + "\n"
self._statistic.append_success(
"Имя модуля: " + plugin['module_name'] + "\n" + "Путь: " + plugin['rel_path'] + "\n" + module_info,
"МОДУЛЬ ИНФО")
def faceva_get_event_image(client: SoapClient, token: str, event: int,
time: int, statistic: Statistic) -> dict:
"""Функция выполнения ws метода FaceVA:GetEventImage.
:param client: объект класса SoapClient для отправки и приема ws запросов;
:param token: токен соединения;
:param event: номер события;
:param time: время события (в unix формате);
:param statistic: объект класса Statistic для ведения статистики ошибок и предупреждений
:return: в случае успеха словарь ответа вида:
{
"img": "base64 code"
}
в случае ошибки словарь вида:
{
"result": "error"
}
"""
logger = statistic.get_log().get_logger("scripts/ws/analytics")
logger.info(
"was called (client: SoapClient, token: str, event: int, time: int, statistic: Statistic)"
)
logger.debug("params (client_obj" + token + ", " + str(event) + ", " +
str(time) + ", stat_obf)")
params, sysparams, method = pattern.faceva_get_event_image(
token, event, time)
response = client.call_method2(method, params, sysparams, [0])
statistic.append_info(method + " выполнен успешно!", "WS МЕТОД")
return response['result'][0]
def faceva_get_frame(client: SoapClient, token: str, camera: int, time: int,
statistic: Statistic) -> dict:
"""Функция выполнения ws метода FaceVA:GetFrame.
:param client: объект класса SoapClient для отправки и приема ws запросов;
:param token: токен соединения;
:param camera: номер камеры;
:param time: время события (в unix формате);
:param statistic: объект класса Statistic для ведения статистики ошибок и предупреждений.
:return: словарь ответа вида:
{
"img": "base64 code"
}
"""
logger = statistic.get_log().get_logger("scripts/ws/analytics")
logger.info(
"was called (client: SoapClient, token: str, event: int, time: int, statistic: Statistic)"
)
logger.debug("params (client_obj" + token + ", " + str(camera) + ", " +
str(time) + ", stat_obf)")
params, sysparams, method = pattern.faceva_get_frame(token, camera, time)
response = client.call_method2(method, params, sysparams, [0])
return response['result'][0]
def faceva_delete_person(client: SoapClient, token: str, name: str,
statistic: Statistic) -> bool:
"""Функция выполнения ws метода FaceVA:DeletePerson
:param client: объект класса SoapClient для отправки и приема ws запросов;
:param token: токен соединения;
:param name:
:param statistic:
:return: флаг успешности операции
"""
logger = log.get_logger("scripts/ws/analytics")
logger.info(
"was called (client: SoapClient, login: str, password: str, name: str, statistic: Statistic)"
)
logger.debug("faceva_delete_person(client_obj" + login + ", " + password +
", " + name + ")")
data = pattern.faceva_delete_person(login, password, name)
response_json = client.call_method2(data[2], data[0], data[1], True)
logger.debug("response_json: " + str(response_json))
tools.check_keys_exist(response_json['result'][0], ['cmd', 'name'],
"response_json['result'][0]", True, statistic)
#tools.check_on_equal_key_values_in_dict(response_json["result"][0], ['cmd', 'name'], ['DeletePerson', name])
logger.info("ws method FaceVA:DeletePerson was executed successfully!")
statistic.append_info(method + " выполнен успешно!", "WS МЕТОД")
return True
def ptzserver_command_simple(client: SoapClient,
key2: str,
token: str,
statistic: Statistic,
stop: bool = False,
left: int = 0,
right: int = 0,
up: int = 0,
down: int = 0,
zoom_in: int = 0,
zoom_out: int = 0,
query_all: bool = False,
go_to_preset: int = 0,
set_preset: int = 0,
pan_to: int = -1,
tilt_to: int = -1,
home: bool = False) -> dict:
"""
:param client:
:param key2:
:param token:
:param stop:
:param left:
:param right:
:param up:
:param down:
:param zoom_in:
:param zoom_out:
:param query_all:
:param go_to_preset:
:param set_preset:
:param pan_to:
:param tilt_to:
:param home:
:return:
"""
logger = statistic.get_log().get_logger("scripts/ws/ptz")
logger.info(
"was called (client: SoapClient, key2: str, token: str, statistic: Statistic, stop: bool,\
left: int, right: int, up: int, down: int, zoom_in: int, zoom_out: int, query_all: bool,\
go_to_preset: int, set_preset: int, pan_to: int, tilt_to: int, home: bool)"
)
logger.debug("params (client_obj, " + key2 + ", " + token +
", statistic_obj" + str(stop) + ", " + str(left) + ", " +
str(right) + ", " + str(up) + ", " + str(down) + ", " +
str(zoom_in) + ", " + str(zoom_out) + ", " + str(query_all) +
", " + str(go_to_preset) + ", " + str(set_preset) + ", " +
str(pan_to) + ", " + str(tilt_to) + ", " + str(home) + ")")
params, sysparams, method = pattern.ptzserver_command_simple(
key2, token, stop, left, right, up, down, zoom_in, zoom_out, query_all,
go_to_preset, set_preset, pan_to, tilt_to, home)
response = client.call_method2(method, params, sysparams, [0])
logger.info("ws method ptzserver:Command was executed successfully!")
statistic.append_info("ptzserver:Command выполнен успешно", "WS_МЕТОД")
return response
def listener_pinger_down_servers(self):
"""Тестирование ws метода listener_pinger:get_down_servers.
Тест циклично с установленной переодичностью опрашивает метод down_servers, затем сравнивает результат с
эталоном (либо из файла, либо самый первый вызов этого метода), затем по порядку вызывает ws методы
listener_pinger:get_local_servers для всех серверов из эталона и сравнивает результаты с эталоном.
"""
ws_client = SoapClient(self._ip, self._port, self._config,
self._statistic)
token = ws_users.server_login(ws_client, self._login, self._password,
self._statistic)
if self._input_data["template_path"]:
template_down_servers: dict = tools.open_json_file(
self._input_data["template_path"], self._statistic)
template_down_servers = template_down_servers["result"][0]["data"][
"string"]
self._statistic.append_info("Получен шаблон из файла...", "ИНФО")
else:
template_down_servers: dict = ws_lp.get_down_servers(
ws_client, token, 1, self._statistic)
self._statistic.append_info(
"Получен шаблон из ws istener_pinger:get_down_servers...",
"ИНФО")
for iteration in range(self._input_data["iterations"]):
local_servers: dict = ws_lp.get_local_servers(
ws_client, token, 1, self._statistic)
if tools_lp.compare_local_servers(local_servers,
template_down_servers, self._ip,
self._statistic):
self._statistic.append_success(
"ответ ws listener_pinger:get_local_servers корректен!",
"СРАВНЕНИЕ")
else:
self._statistic.append_error(
"ответ ws listener_pinger:get_local_servers некорректен!",
"КРИТ", True)
down_servers: dict = ws_lp.get_down_servers(
ws_client, token, 1, self._statistic)
if tools_lp.compare_down_servers(down_servers,
template_down_servers, self._ip,
self._statistic):
self._statistic.append_success(
"ответ ws listener_pinger:get_down_servers корректен!",
"СРАВНЕНИЕ")
else:
self._statistic.append_error(
"ответ ws listener_pinger:get_down_servers некорректен!",
"КРИТ", True)
time.sleep(self._input_data["period"])
def get_down_servers(client: SoapClient, token: str, direct_access: int,
statistic: Statistic) -> dict:
"""WS метод listener_pinger_get_down_servers с проверками существования ключей и типов их значений.
:param client: объект клиента;
:param token: токен авторизации;
:param direct_access: параметр ws метода;
:param statistic: объект класса Statistic.
:return: response["result"][0]["data"]["string"]
"""
logger = statistic.get_log().get_logger("scripts/ws/listener_pinger")
logger.info(
"was called (client: SoapClient, token: str, direct_access: int, statistic: Statistic)"
)
logger.debug("with params (client_obj, " + token + ", " +
str(direct_access) + ", stat_obj)")
params, sysparams, method = pattern.listener_pinger_get_down_servers(
token, direct_access)
response = client.call_method2(method, params, sysparams, [0])
tools.check_types(["response['result'][0]"], [response["result"][0]],
[dict], statistic)
tools.check_keys_exist(response["result"][0], ['data', 'hash'],
'response["result"][0]', False, statistic)
tools.check_types(
['data', 'hash'],
[response["result"][0]["data"], response["result"][0]["hash"]],
[dict, str], statistic)
tools.check_keys_exist(response["result"][0]["data"], ['string'],
'response["result"][0]["data"]', False, statistic)
tools.check_types(["response['result'][0]['data']['string']"],
[response["result"][0]["data"]["string"]], [dict],
statistic)
string = response["result"][0]["data"]["string"]
tools_lp.listener_pinger_keys_verifier(string, statistic)
for down_server in string["down_servers"]:
for key in down_server:
tools_lp.listener_pinger_keys_verifier(down_server[key], statistic)
logger.info("ws '" + method + "' выполнен успешно!")
statistic.append_info(method + "' выполнен успешно!", "WS_МЕТОД")
return response["result"][0]["data"]["string"]
def ptzserver_list_profiles(client: SoapClient, token: str,
statistic: Statistic) -> list:
logger = statistic.get_log().get_logger("scripts/ws/ptz")
logger.info(
"was called (client: SoapClient, token: str, statistic: Statistic)")
logger.debug("with params (client_obj, " + token + ", stat_obj)")
params, sysparams, method = pattern.ptzserver_list_profiles(token)
response = client.call_method2(method, params, sysparams, [0])
logger.info("ws method " + method + " was executed successfully!")
statistic.append_info(method + " выполнен успешно!", "WS_МЕТОД")
if not response["result"] or response["result"] == [{}]:
statistic.append_error("Список PTZ камер пуст!", "НЕТ PTZ КАМЕР")
return []
return response["result"]
def faceva_get_data_base(client: SoapClient, token: str,
statistic: Statistic) -> tuple:
"""Функция выполнеия ws метода FaceVA:GetDataBase
:param client: объект класса SoapClient для отправки и приема ws запросов;
:param token: токен соединения;
:param statistic: объект класса Statistic для ведения статистики ошибок и предупреждений.
:return: список персон, который приходит в ответе в ключе persons вида:
[
{
"id": 26617065162932227,
"name": Иванов Иван Иванович,
["pacs": 1],
["category": "category"],
["department": "department"],
["comment": "comment"],
["information": "information"]
}
]
"""
logger = statistic.get_log().get_logger("scripts/ws/analytics")
logger.info("was called(client, login, password)")
logger.debug("with params (client_obj, " + token + ", stat_obj)")
params, sysparams, method = pattern.faceva_get_data_base(token)
response_json = client.call_method2(method, params, sysparams, [0])
result = response_json["result"][0]
tools.check_keys_exist(result, ['persons'], "result", True, statistic)
persons = result["persons"]
tools.check_types(["persons"], [persons], [list], statistic)
if not persons:
statistic.append_warn("data base persons", "EMPTY")
for person in persons:
tools.check_keys_exist(person, ["id", "name"], 'person', True,
statistic)
logger.info("ws method FaceVA:GetDataBase was executed successfully!")
statistic.append_info(method + " выполнен успешно!", "WS МЕТОД")
return tuple(persons)
def test_analytic_events(self):
"""Тест строит указанное кол-во графов устройство->микшер->ИВ54сервер->аналитика,
затем ожидает конца дампа/ави и сравнивает фактичиские события с указанными в data
"""
analytic_block: dict = tools.open_json_file(self._input_data['json'],
self._statistic)
cam_json = graph.create_json_from_profiles(
self._input_data['server'], analytic_block,
self._input_data['video_source'], True, self._statistic)
ws_client = SoapClient(self._server_ip, self._server_port,
self._config, self._statistic)
token: str = ws_users.server_login(ws_client, self._login,
self._password, self._statistic)
cam_name: str = graph.insert_graphs_to_db(ws_client, token,
self._server_db_path,
cam_json,
self._input_data['server'],
self._input_data['profile'],
1, self._statistic)[0]
if self._input_data['detector'] == "forget2":
event_type = 20074
elif self._input_data['detector'] == "FaceVA":
event_type = 20013
else:
self._statistic.append_error(self._input_data['detector'],
"НЕТ ДЕТЕКТОРА", True)
cam_info = {
"server": self._input_data['server'],
"cam": cam_name,
"profile": self._input_data['profile']
}
analytics.run_events_test(ws_client, token, cam_info,
self._input_data['events'],
self._input_data['inaccuracy'], event_type,
self._input_data['video_source'],
self._statistic)
def faceva_update_person(client: SoapClient, token: str, id_: int,
pacs_id: int, name: str, category: str, comment: str,
information: str, department: str, faces: Tuple[dict],
delete_faces: Tuple[dict],
statistic: Statistic) -> str:
"""Функция выполнения ws метода FaceVA:UpdatePerson.
:param client: объект класса SoapClient для отправки и приема ws запросов;
:param token: токен соединения;
:param id_: идентификатор персоны в БД;
:param pacs_id: идентификатор персоны в БД для СКД;
:param name: ФИО персоны;
:param category: категория;
:param comment: комментарий;
:param information: информация;
:param department: отдел;
:param faces: список фото лиц для добавления;
:param delete_faces: список фото для удаления;
:param statistic: объект класса Statistic для ведения статистики ошибок и предупреждений.
:return: идентификатор персоны в базе.
"""
logger = statistic.get_log().get_logger("scripts/ws/analytics")
logger.info(
"was called faceva_update_person(client: SoapClient, login: str, id_: int, pacs_id: int,\
name: str, category: str, comment: str, information: str, department: str, faces: List[dict], \
delete_faces: List[dict])")
logger.debug("faceva_update_person(client_obj" + token + ", " + str(id_) +
", " + str(pacs_id) + ", " + name + ", " + category + ", " +
comment + ", " + information + ", " + department + ", " +
", " + str(faces) + ", " + str(delete_faces) + ")")
params, sysparams, method = pattern.faceva_update_person(
token, id_, pacs_id, name, category, comment, information, department,
faces, delete_faces)
response_json = client.call_method2(method, params, sysparams, [0])
person = response_json['result'][0]
key_names = [
"id", "pacs", "name", "category", "comment", "information",
"department", "result", "faces"
]
tools.check_keys_exist(person, key_names, "['result'][0]", True, statistic)
key_names.remove("result")
key_names.remove("faces")
key_values = [
person["id"], person["pacs"], person["name"], person["category"],
person["comment"], person["information"], person["department"]
]
key_need_values = [
id_,
str(pacs_id), name, category, comment, information, department
]
operations = ["==", "==", "==", "==", "==", "==", "=="]
if id_ == -1:
key_names.pop(0)
key_values.pop(0)
key_need_values.pop(0)
operations.pop(0)
tools.check_values(key_names, key_values, key_need_values, operations,
statistic)
tools.check_types(["faces"], [person["faces"]], [list], statistic)
if not person['faces'] and faces:
statistic.append_error("Список faces", "НЕТ_ЛИЦ", True)
for index, face in enumerate(person["faces"]):
tools.check_keys_exist(face, ["result"], "face", True, statistic)
if face["result"] == "error":
tools.check_keys_exist(face, ["reason"], "face", True, statistic)
statistic.append_error("причина: " + face["reason"], "ПЛОХОЕ_ФОТО",
False)
logger.info("ws method FaceVA:UpdatePerson was executed successfully!")
statistic.append_info(method + " выполнен успешно!", "WS МЕТОД")
return person["id"]
def faceva_get_faces(client: SoapClient, token: str, from_: int,
statistic: Statistic) -> Tuple[dict]:
"""Функция выполнения ws метода FaceVA:GetFaces.
:param client: объект класса SoapClient для отправки и приема ws запросов;
:param token: токен соединения;
:param from_: начиная с какого id прислать события
:param statistic: объект класса Statistic для ведения статистики ошибок и предупреждений
:return: список словарей с событиями вида:
[
{
"event": 154743,
"camera": 1955154395,
"person": "26617065381036041", // если не пустой, значит это СВОЙ, иначе просто обнаруженное лицо.
"score": 0.939386,
"time": 1587380094085000,
"img": "base64"
},
...
...
]
"""
logger = statistic.get_log().get_logger("scripts/ws/analytics")
logger.info(
"was called (client: SoapClient, token: str, from_: int, statistic: Statistic)"
)
logger.debug("params (client_obj" + token + ", " + str(from_) +
", stat_obf)")
params, sysparams, method = pattern.faceva_get_faces(token, from_)
response: dict = client.call_method2(method, params, sysparams, [0])
for index, event in enumerate(response['result']):
# пришлось написать это условие, так как может быть ситуация: result: [{}],
# это означает, что событий нет.
if not event and len(response['result']) == 1:
break
key_names = ['event', 'camera', 'rect', 'score', 'time', 'img']
tools.check_keys_exist(event, key_names, "result[" + str(index) + "]",
True, statistic)
key_values = [
event['event'], event['camera'], event['rect'], event['score'],
event['time'], event['img']
]
tools.check_types(key_names, key_values,
[int, int, dict, float, int, str], statistic)
key_names = ['x', 'y', 'w', 'h']
tools.check_keys_exist(event['rect'], key_names,
"result[" + str(index) + "]['rect']", True,
statistic)
key_values = [
event['rect']['x'], event['rect']['y'], event['rect']['w'],
event['rect']['h']
]
tools.check_types(key_names, key_values, [int, int, int, int],
statistic)
statistic.append_info(method + " выполнен успешно!", "WS МЕТОД")
return tuple(response['result'])
def listener_pinger_ptz_status(self):
"""Тестирование ws методов listener_pinger:get_down_servers и listener_pinger:get_local_servers с целью
проверки статусов ptz камер.
Тест циклично с установленной переодичностью опрашивает методы local_servers и down_servers, проходит по каждым
потенциально ptz камерам рутового (верхнего) сервера и проверяет статус ptz.
"""
# ----------------------------------------
# ПРОВЕРКА ВХОДНЫХ ДАННЫХ
key_names = ['template_path', 'period', 'iterations']
tools.check_keys_exist(self._input_data, key_names, 'data', True,
self._statistic)
key_values = [
self._input_data["template_path"], self._input_data["period"],
self._input_data["iterations"]
]
tools.check_types(key_names, key_values, [str, int, int],
self._statistic)
# ----------------------------------------
ws_client = SoapClient(self._ip, self._port, self._config,
self._statistic)
token = ws_users.server_login(ws_client, self._login, self._password,
self._statistic)
if self._input_data["template_path"]:
template_ptz_list_profiles: dict = tools.open_json_file(
self._input_data["template_path"], self._statistic)
template_ptz_list_profiles: list = template_ptz_list_profiles[
"result"]
self._statistic.append_info("Получен шаблон из файла...", "ИНФО")
else:
template_ptz_list_profiles: list = ws_ptz.ptzserver_list_profiles(
ws_client, token, self._statistic)
if not template_ptz_list_profiles:
self._statistic.append_error(
"Неуспешно... Список PTZ камер пуст!", "ПОЛУЧЕНИЕ ШАБЛОНА",
True)
self._statistic.append_info(
"Получен шаблон из ws ptzserver:list_profiles...", "ИНФО")
if not template_ptz_list_profiles:
self._statistic.append_error("Пустой список камер в шаблоне!",
"ВХ_ДАННЫЕ", True)
for iteration in range(self._input_data["iterations"]):
local_servers: dict = ws_lp.get_local_servers(
ws_client, token, 1, self._statistic)
if tools_lp.check_ptz_cams(local_servers["cams"],
template_ptz_list_profiles,
self._statistic):
self._statistic.append_success(
"Статусы PTZ в ответе ws listener_pinger:get_local_servers корректны!",
"ТЕСТ")
else:
self._statistic.append_error(
"Статусы PTZ в ответе ws listener_pinger:get_local_servers некорректны!",
"КРИТ", True)
down_servers: dict = ws_lp.get_down_servers(
ws_client, token, 1, self._statistic)
if tools_lp.check_ptz_cams(down_servers["cams"],
template_ptz_list_profiles,
self._statistic):
self._statistic.append_success(
"Статусы PTZ в ответе ws listener_pinger:get_down_servers корректны!",
"ТЕСТ")
else:
self._statistic.append_error(
"Статусы PTZ в ответе ws listener_pinger:get_down_servers некорректны!",
"КРИТ", True)
time.sleep(self._input_data["period"])
def test_faceva_get_event(self):
"""Тест проверяет ws метод FaceVA:GetEvent.
Тест может работать в двух режимах: skd_mode = True - используются только ws методы лиц, то есть точно также,
как и вызвает их СКД; skd_mode = False - за эталон берутся события системы и сравниваются с событиями от лиц,
таким образом проверяются возможные пропуски.
max_counts_event - кол-во событий для проверки, при достижении которых тест должен завершиться.
event_getting_timeout - как часто запрашивать события, в случае если они не были найдены.
"""
ws_client = SoapClient(self._server_ip, self._server_port,
self._config, self._statistic)
token: str = ws_users.server_login(ws_client, self._login,
self._password, self._statistic)
current_time = ws_common.get_current_server_time(
ws_client, token, self._statistic)
events_count = 0
last_event_time = current_time
last_event_id = 0
from_event = 0
while True:
if self._input_data['skd_mode']:
events: Tuple[dict] = ws_analytics.faceva_get_event(
ws_client, token, from_event, self._statistic)
else:
events: Tuple[dict] = ws_ewriter.select(
ws_client, token, last_event_time, None, None, [20013],
None, None, None, self._statistic)
events: list = list(events)
events.reverse()
if not events or len(events) == 1 and events[0] == {}:
time.sleep(self._input_data['event_getting_timeout'])
continue
events: tuple = tuple(events)
self._statistic.append_info("Получены события", "ИНФО")
for index, event in enumerate(events):
events_count += 1
if self._input_data['skd_mode'] is False:
# пропускаем старые (уже проверенные) события
if event['evtid'] <= last_event_id:
events_count -= 1
continue
faceva_events: Tuple[dict] = ws_analytics.faceva_get_event(
ws_client, token, 0, self._statistic)
index_faceva_event = tools.get_dict_by_keys_values(
faceva_events, ('event', ), (event['evtid'], ))
if index_faceva_event < 0:
self._statistic.append_error(
"Нет события: " + str(event['evtid']) + "!",
"КРИТ", True)
person_id = faceva_events[index_faceva_event]['person']
persons = ws_analytics.faceva_get_data_base(
ws_client, token, self._statistic)
index_person = tools.get_dict_by_keys_values(
persons, ('id', ), (person_id, ))
if index_person < 0:
self._statistic.append_error(
"В базе нет id: " + str(person_id) + "!", "КРИТ",
True)
person_name = persons[index_person]['name']
if event['evtcomment'].find(person_name) < 0:
self._statistic.append_error(
"ФИО персоны не совпадают в событии " +
str(event['evtid']) + "!", "НЕВАЛИД ЗНАЧ", False)
event_id = faceva_events[index_faceva_event]['event']
time_ = faceva_events[index_faceva_event]['time']
camera = faceva_events[index_faceva_event]['camera']
event_time: str = event['evttime']
date_event_time = tools.get_date_from_str(event_time)
last_event_time = str(
tools.convert_time_to_gtc(date_event_time))[:-3]
last_event_id = event_id
else:
event_id = event['event']
time_ = event['time']
camera = event['camera']
from_event = event_id
# Проверка получения кадра по событию.
# Выполнение ws метода FaceVA:GetFrame
ws_result = ws_analytics.faceva_get_frame(
ws_client, token, camera, time_, self._statistic)
if tools.check_keys_exist(ws_result, ['img'], 'result[0]',
False, self._statistic) is False:
self._statistic.append_error(
"По событию " + str(event_id) + "!",
"ОТСУТСТВУЕТ КАДР", True)
elif not ws_result['img']:
self._statistic.append_error(
"По событию " + str(event_id) + "!",
"ОТСУТСТВУЕТ КАДР", True)
else:
self._statistic.append_success(
"По событию '" + str(event_id) + "'!", "ПОЛУЧЕН КАДР")
# Проверка получения картинки по событию.
# Выполнение ws метода FaceVA:GetEventImage
ws_result = ws_analytics.faceva_get_event_image(
ws_client, token, event_id, time_, self._statistic)
if tools.check_keys_exist(ws_result, ['img'], 'result[0]',
False, self._statistic) is False:
self._statistic.append_error(
"По событию " + str(event_id) + "!",
"ОТСУТСТВУЕТ КАРТИНКА", True)
elif not ws_result['img']:
self._statistic.append_error(
"По событию " + str(event_id) + "!",
"ОТСУТСТВУЕТ КАРТИНКА", True)
else:
self._statistic.append_success(
"По событию " + str(event_id) + "!",
"ПОЛУЧЕНА КАРТИНКА")
if events_count >= self._input_data['max_count_events']:
break
if events_count >= self._input_data['max_count_events']:
break
def test_faceva_update_person(self):
"""Тест проверяет работу ws метода FaceVA:UpdatePerson.
Тест добавляет с помощью этого ws метода персон из указанной директории, в которой находятся папки,
имена которых являются ФИО персоны, а внутри каждой папки фотографии этой персоны. После каждого добавления
вызывается метода FaceVA:GetDataBase с целью фактической проверки добавления человека.
"""
ws_client = SoapClient(self._server_ip, self._server_port,
self._config, self._statistic)
token = ws_users.server_login(ws_client, self._login, self._password,
self._statistic)
# получение текущего списка людей в БД
old_persons_db = ws_analytics.faceva_get_data_base(
ws_client, self._login, self._statistic)
persons_dir = tools.get_dirs(self._input_data["persons_dir"])
for person in persons_dir:
name: str = person
category: str = str(random.randint(0, 100000))
comment: str = random.choice([
"На больничном", "Удаленная работа", "Полная ставка",
"Пол ставки", "Фрилансер"
])
information: str = random.choice([
"Программист", "Тестировщик", "Директор",
"Начальник отдела тестирования", "Менеджер по продажам"
])
department: str = random.choice(
["Тестирования", "Разработки ПО", "Продаж", "Кадров"])
person_photos: Tuple[str] = tools.get_files(
self._input_data["persons_dir"] + "/" + person)
photo_paths = []
for person_photo in person_photos:
photo_paths.append(self._input_data["persons_dir"] + "/" +
person + "/" + person_photo)
photos_base64: Tuple[str] = tools.get_photos_base64(
tuple(photo_paths))
faces = []
for photo_base64 in photos_base64:
faces.append({"img": str(photo_base64)})
while True:
pacs_id: int = random.randint(0, 1000)
if tools.get_dict_by_keys_values(old_persons_db, ("pacs", ),
(pacs_id, )) == -1:
break
person_id = ws_analytics.faceva_update_person(
ws_client, token, -1, pacs_id, name, category, comment,
information, department, faces, [], self._statistic)
current_persons_db = ws_analytics.faceva_get_data_base(
ws_client, token, self._statistic)
key_names = ("id", "name", "pacs", "category", "comment",
"information", "department")
key_values = (person_id, name, pacs_id, category, comment,
information, department)
if tools.get_dict_by_keys_values(current_persons_db, key_names,
key_values) == -1:
self._statistic.append_error(name, "ПЕРСОНА НЕ ДОБАВЛЕНА",
True)
self._statistic.append_success(name, "ПЕРСОНА ДОБАВЛЕНА")
"""# запуск удаления
