CITKParus/TCF-Framework-Integration
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Фиксация доработок по обучению

Browse Source 
Формирование файла dataset; Загрузка на файловый ресурс SCP; Передача данных фреймворку; Запрос на обучение модели.
This commit is contained in:
Skillbox Student 2025-03-24 19:26:22 +03:00
parent 740d5e0aef
commit 962e3208ce
7 changed files with 2506 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1129
db/UDO_PKG_EQUIPDS_DATAPROCESS.pck Normal file
View File

File diff suppressed because it is too large Load Diff

641
db/UDO_PKG_EQUIPDS_EXS.pck Normal file
View File

@ -0,0 +1,641 @@
create or replace package UDO_PKG_EQUIPDS_EXS
is
/*
Описание: Реализует методы «Сервиса интеграции с WEB API» для взаимодействия с внешней системой (обработчики ответов и сообщений).
Проект: Интеграция ПП «Парус 8» и «Фреймворка оценки и прогнозирования состояния оборудования»
Разработчик: ЦИТК-ПАРУС
Отественный: Селианов А.Е.
Дата последнего изменения: 15.02.2025
*/
/* Константы - параметры "Типовых сообщений обмена" Загрузка данных на файловый сервер SCP для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_MSGTYPE_CODE_LSCP constant PKG_STD.TSTRING := 'Загрузка_на_SCP'; -- Мнемокод типовых сообщений обмена
SEQUIPDS_MSGTYPE_NAME_LSCP constant PKG_STD.TSTRING := 'Загрузка данных на файловый сервер SCP'; -- Наименование типовых сообщений обмена
SEQUIPDS_MSGTYPE_PKG_LSCP constant PKG_STD.TSTRING := 'UDO_PKG_EQUIPDS_EXS'; -- Пакет обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_PRC_LSCP constant PKG_STD.TSTRING := 'P_UPLOADFILESCP'; -- Процедура обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_SRVBFR_LSCP constant PKG_STD.TSTRING := 'loadSCP_v2.js/uploadFileSCP'; -- Функция предобработки сервером приложений
/* Константы - параметры "Типовых сообщений обмена" Передача выборки данных Фреймворку для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_MSGTYPE_CODE_LFRM constant PKG_STD.TSTRING := 'Передача_данных_Фреймворку'; -- Мнемокод типовых сообщений обмена
SEQUIPDS_MSGTYPE_NAME_LFRM constant PKG_STD.TSTRING := 'Передача выборки данных Фреймворку'; -- Наименование типовых сообщений обмена
SEQUIPDS_MSGTYPE_PKG_LFRM constant PKG_STD.TSTRING := 'UDO_PKG_EQUIPDS_EXS'; -- Пакет обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_PRC_LFRM constant PKG_STD.TSTRING := 'P_METADATA'; -- Процедура обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_SRVBFR_LFRM constant PKG_STD.TSTRING := 'EQUIPDS.js/beforeDocParse'; -- Функция предобработки сервером приложений
SEQUIPDS_MSGTYPE_SRVAFTR_LFRM constant PKG_STD.TSTRING := 'EQUIPDS.js/afterDocParseResp'; -- Функция постобработки сервером приложений
/* Константы - параметры "Типовых сообщений обмена" Передача Фреймворку запроса на обучение модели для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_MSGTYPE_CODE_RQLRN constant PKG_STD.TSTRING := 'Запрос на обучение'; -- Мнемокод типовых сообщений обмена
SEQUIPDS_MSGTYPE_NAME_RQLRN constant PKG_STD.TSTRING := 'Передача Фреймворку запроса на обучение модели'; -- Наименование типовых сообщений обмена
SEQUIPDS_MSGTYPE_PKG_RQLRN constant PKG_STD.TSTRING := 'UDO_PKG_EQUIPDS_EXS'; -- Пакет обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_PRC_RQLRN constant PKG_STD.TSTRING := 'P_REQUIREMENTS'; -- Процедура обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_SRVBFR_RQLRN constant PKG_STD.TSTRING := 'EQUIPDS.js/beforeDocParse'; -- Функция предобработки сервером приложений
SEQUIPDS_MSGTYPE_SRVAFTR_RQLRN constant PKG_STD.TSTRING := 'EQUIPDS.js/afterDocParseResp'; -- Функция постобработки сервером приложений
/* Константы - параметры "Типовых сообщений обмена" Получение состояния загрузки данных Фреймворком, после выполнения для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_MSGTYPE_CODE_MTCB constant PKG_STD.TSTRING := 'Статус_загрузки_данных_Фреймфорка'; -- Мнемокод типовых сообщений обмена
SEQUIPDS_MSGTYPE_NAME_MTCB constant PKG_STD.TSTRING := 'Получение состояния загрузки данных Фреймворком, после выполнения'; -- Наименование типовых сообщений обмена
SEQUIPDS_MSGTYPE_PKG_MTCB constant PKG_STD.TSTRING := 'UDO_PKG_EQUIPDS_EXS'; -- Пакет обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_PRC_MTCB constant PKG_STD.TSTRING := 'P_METADATA_CB'; -- Процедура обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_SRVBFR_MTCB constant PKG_STD.TSTRING := 'EQUIPDS.js/beforeDocParseMsg'; -- Функция предобработки сервером приложений
/* Константы - параметры "Типовых сообщений обмена" Получение состояния загрузки данных Фреймворком, после выполнения для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_MSGTYPE_CODE_REQCB constant PKG_STD.TSTRING := 'Состояние_обучения_модели'; -- Мнемокод типовых сообщений обмена
SEQUIPDS_MSGTYPE_NAME_REQCB constant PKG_STD.TSTRING := 'Получение состояния обучения модели Фреймворком, после выполнения'; -- Наименование типовых сообщений обмена
SEQUIPDS_MSGTYPE_PKG_REQCB constant PKG_STD.TSTRING := 'UDO_PKG_EQUIPDS_EXS'; -- Пакет обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_PRC_REQCB constant PKG_STD.TSTRING := 'P_REQUIREMENTS_CB'; -- Процедура обработки типового сообщения обмена
SEQUIPDS_MSGTYPE_SRVBFR_REQCB constant PKG_STD.TSTRING := 'EQUIPDS.js/beforeDocParseMsg'; -- Функция предобработки сервером приложений
/* Константы - параметры "Сервисов обмена" Загрузка_на_SCP для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_SRVC_CODE_LSCP constant PKG_STD.TSTRING := 'Загрузка_на_SCP'; -- Мнемокод сервиса обмена
SEQUIPDS_SRVC_NAME_LSCP constant PKG_STD.TSTRING := 'Загрузка данных на SCP'; -- Наименование сервиса обмена
NEQUIPDS_SRVC_SRV_TYPE_LSCP constant PKG_STD.TNUMBER := PKG_EXS.NSRV_TYPE_SEND; -- Тип сервера
SEQUIPDS_SRVC_SRV_ROOT_LSCP constant PKG_STD.TSTRING := 'sftp://parus.cadred.ru:62322'; -- Адрес сервера
/* Константы - параметры "Сервисов обмена" Передача данных Фреймворку для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_SRVC_CODE_LFRM constant PKG_STD.TSTRING := 'Загрузка_на_Фреймворк'; -- Мнемокод сервиса обмена
SEQUIPDS_SRVC_NAME_LFRM constant PKG_STD.TSTRING := 'Передача данных Фреймворку'; -- Наименование сервиса обмена
NEQUIPDS_SRVC_SRV_TYPE_LFRM constant PKG_STD.TNUMBER := PKG_EXS.NSRV_TYPE_SEND; -- Тип сервера
SEQUIPDS_SRVC_SRV_ROOT_LFRM constant PKG_STD.TSTRING := 'https://parus.cadred.ru/API/train'; -- Адрес сервера
/* Константы - параметры "Сервисов обмена" Получение обратной связи от Фреймворка для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_SRVC_CODE_CLLBCK constant PKG_STD.TSTRING := 'Поучение_от_Фреймворка'; -- Мнемокод сервиса обмена
SEQUIPDS_SRVC_NAME_CLLBCK constant PKG_STD.TSTRING := 'Получение обратной связи от Фреймворка'; -- Наименование сервиса обмена
NEQUIPDS_SRVC_SRV_TYPE_CLLBCK constant PKG_STD.TNUMBER := PKG_EXS.NSRV_TYPE_RECIVE; -- Тип сервера
SEQUIPDS_SRVC_SRV_ROOT_CLLBCK constant PKG_STD.TSTRING := '/equipds'; -- Адрес сервера
/* Константы - параметры "Функции сервиса обмена" Загрузка_на_SCP для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_SRVCFN_CODE_LSCP constant PKG_STD.TSTRING := 'Загрузка_на_SCP'; -- Мнемокод функции сервиса обмена
SEQUIPDS_SRVCFN_NAME_LSCP constant PKG_STD.TSTRING := 'Загрузка данных на SCP'; -- Наименование функции сервиса обмена
NEQUIPDS_SRVCFN_FN_TYPE_LSCP constant PKG_STD.TNUMBER := PKG_EXS.NFN_TYPE_DATA; -- Типовая функция
SEQUIPDS_SRVCFN_FN_URL_LSCP constant PKG_STD.TSTRING := 'home/sftp_user/parus'; -- Адрес функции сервиса обмена
NEQUIPDS_SRVCFN_FNPRMS_TP_LSCP constant PKG_STD.TNUMBER := PKG_EXS.NFN_PRMS_TYPE_POST; -- Способ передачи параметров
/* Константы - параметры "Функции сервиса обмена" Передача данных Фреймворку для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_SRVCFN_CODE_LFRM constant PKG_STD.TSTRING := 'Загрузить_на_Фреймворк'; -- Мнемокод функции сервиса обмена
SEQUIPDS_SRVCFN_NAME_LFRM constant PKG_STD.TSTRING := 'Передача выборки данных Фреймворку'; -- Наименование функции сервиса обмена
NEQUIPDS_SRVCFN_FN_TYPE_LFRM constant PKG_STD.TNUMBER := PKG_EXS.NFN_TYPE_DATA; -- Типовая функция
SEQUIPDS_SRVCFN_FN_URL_LFRM constant PKG_STD.TSTRING := 'metadata'; -- Адрес функции сервиса обмена
NEQUIPDS_SRVCFN_FNPRMS_TP_LFRM constant PKG_STD.TNUMBER := PKG_EXS.NFN_PRMS_TYPE_POST; -- Способ передачи параметров
/* Константы - параметры "Функции сервиса обмена" Передача Фреймворку запроса на обучение модели для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_SRVCFN_CODE_RQLRN constant PKG_STD.TSTRING := 'Запрос на обучение'; -- Мнемокод функции сервиса обмена
SEQUIPDS_SRVCFN_NAME_RQLRN constant PKG_STD.TSTRING := 'Передача Фреймворку запроса на обучение модели'; -- Наименование функции сервиса обмена
NEQUIPDS_SRVCFN_FN_TYPE_RQLRN constant PKG_STD.TNUMBER := PKG_EXS.NFN_TYPE_DATA; -- Типовая функция
SEQUIPDS_SRVCFN_FN_URL_RQLRN constant PKG_STD.TSTRING := 'requirements'; -- Адрес функции сервиса обмена
NEQUIPDS_SRVCFN_FNPR_TP_RQLRN constant PKG_STD.TNUMBER := PKG_EXS.NFN_PRMS_TYPE_POST; -- Способ передачи параметров
/* Константы - параметры "Функции сервиса обмена" Получение состояния загрузки данных Фреймворком, после выполнения для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_SRVCFN_CODE_MTCB constant PKG_STD.TSTRING := 'Статус_загрузки_данных_Фреймфорка'; -- Мнемокод функции сервиса обмена
SEQUIPDS_SRVCFN_NAME_MTCB constant PKG_STD.TSTRING := 'Получение состояния загрузки данных Фреймворком, после выполнения'; -- Наименование функции сервиса обмена
NEQUIPDS_SRVCFN_FN_TYPE_MTCB constant PKG_STD.TNUMBER := PKG_EXS.NFN_TYPE_DATA; -- Типовая функция
SEQUIPDS_SRVCFN_FN_URL_MTCB constant PKG_STD.TSTRING := 'API/train/metadata/metadata_cb'; -- Адрес функции сервиса обмена
NEQUIPDS_SRVCFN_FNPRMS_TP_MTCB constant PKG_STD.TNUMBER := PKG_EXS.NFN_PRMS_TYPE_POST; -- Способ передачи параметров
/* Константы - параметры "Функции сервиса обмена" Получение состояния загрузки данных Фреймворком, после выполнения для интеграции с фреймворк по прогнозированию ресурса оборудования */
SEQUIPDS_SRVCFN_CODE_REQCB constant PKG_STD.TSTRING := 'Статус_обучения_модели'; -- Мнемокод функции сервиса обмена
SEQUIPDS_SRVCFN_NAME_REQCB constant PKG_STD.TSTRING := 'Получение состояния обучения модели Фреймворком, после выполнения'; -- Наименование функции сервиса обмена
NEQUIPDS_SRVCFN_FN_TYPE_REQCB constant PKG_STD.TNUMBER := PKG_EXS.NFN_TYPE_DATA; -- Типовая функция
SEQUIPDS_SRVCFN_FN_URL_REQCB constant PKG_STD.TSTRING := 'API/train/requirements/requirements_cb'; -- Адрес функции сервиса обмена
NEQUIPDS_SRVCFN_FNPR_TP_REQCB constant PKG_STD.TNUMBER := PKG_EXS.NFN_PRMS_TYPE_POST; -- Способ передачи параметров
/* Обработка загрузки файлов на SCP сервер */
procedure P_UPLOADFILESCP
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
);
/* Обработка передачи выборки данных Фреймворку */
procedure P_METADATA
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
);
/* Обработка передачи Фреймворку запроса на обучение модели */
procedure P_REQUIREMENTS
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
);
/* Обработка получения состояния загрузки данных Фреймворком*/
procedure P_METADATA_CB
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
);
/* Обработка получение состояния обучения модели Фреймворком */
procedure P_REQUIREMENTS_CB
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
);
/* Инициализация настроек расширения для интеграции с фреймворк по прогнозированию ресурса оборудования */
procedure INIT_EQUIPDS
(
NCRN in number, -- Рег. номер каталога сервиса обмена
NFORCE_UPDATE in number -- Обновлять существующие записи (см. константы PKG_EXS.NFORCE_UPDATE_*)
);
end UDO_PKG_EQUIPDS_EXS;
/
create or replace package body UDO_PKG_EQUIPDS_EXS
is
/* Обработка загрузки файлов на SCP сервер */
procedure P_UPLOADFILESCP
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
)
is
REXSQUEUE EXSQUEUE%ROWTYPE; -- заить очереди обмена
SSTATE PKG_STD.tSTRING; -- Код состояния отработки 200- успех; 500 - ошибка
SMESSAGE PKG_STD.tSTRING; -- Текст ошибки
SFILENAME PKG_STD.tSTRING; -- Имя ффайла с путём размещения на файлсерере SCP
begin
/* Поиск записи очереди обмена */
REXSQUEUE := GET_EXSQUEUE_ID(NFLAG_SMART => 0, NRN => NEXSQUEUE);
/* Читаем статус запроса */
SSTATE := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'state');
SMESSAGE := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'message');
case SSTATE
when '200' then
SFILENAME := PKG_EXS.OPTIONS_READ(sOPTIONS => REXSQUEUE.OPTIONS,
SPATH => 'SPATCH_FSERV');
/* Базовая установка имени файла "Выборки данных оборудования (классы оборудования, файлы данных)" */
UDO_PKG_EQUIPDS_BASE.CMFL_SET_FILE_NAME(NRN => REXSQUEUE.LNK_DOCUMENT,
SFILE_NAME => SFILENAME);
/* Базовая установка состояния "Выборки данных оборудования (классы оборудования, файлы данных)" */
UDO_PKG_EQUIPDS_BASE.CMFL_SET_STATUS(NRN => REXSQUEUE.LNK_DOCUMENT,
NSTATUS => UDO_PKG_EQUIPDS_BASE.NCMFL_STATUS_UPLOADED,
SQUEUE_ID => null,
SERR => null);
else
/* Базовая установка состояния "Выборки данных оборудования (классы оборудования, файлы данных)" */
UDO_PKG_EQUIPDS_BASE.CMFL_SET_STATUS(NRN => REXSQUEUE.LNK_DOCUMENT,
NSTATUS => UDO_PKG_EQUIPDS_BASE.NCMFL_STATUS_UPLOAD_ERR,
SQUEUE_ID => null,
SERR => SMESSAGE);
end case;
/* Возвращаем ответ */
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_OK);
exception
when others then
/* Вернём ошибку - это фатальная */
PKG_STATE.DIAGNOSTICS_STACKED();
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_ERR,
SMSG => PKG_STATE.SQL_ERRM());
end P_UPLOADFILESCP;
/* Обработка передачи выборки данных Фреймворку */
procedure P_METADATA
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
)
is
REXSQUEUE EXSQUEUE%ROWTYPE; -- заить очереди обмена
SSTATE PKG_STD.tSTRING; -- Код состояния отработки 200- успех; 500 - ошибка
SMESSAGE PKG_STD.tSTRING; -- Текст ошибки
NSTATUS PKG_STD.tNUMBER; -- состояния "Выборки данных оборудования (классы оборудования, файлы данных)"
SQUEUE_ID PKG_STD.tSTRING; --
SERR PKG_STD.tSTRING; -- Текст ошибки
begin
/* Поиск записи очереди обмена */
REXSQUEUE := GET_EXSQUEUE_ID(NFLAG_SMART => 0, NRN => NEXSQUEUE);
/* Читаем статус запроса */
SSTATE := PKG_EXS.OPTIONS_READ(sOPTIONS => REXSQUEUE.OPTIONS_RESP,
SPATH => 'statusCode');
SMESSAGE := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(REXSQUEUE.RESP, PKG_CHARSET.CHARSET_UTF_),
SPATH => 'message');
SQUEUE_ID := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(REXSQUEUE.RESP, PKG_CHARSET.CHARSET_UTF_),
SPATH => 'queue_id');
case SSTATE
when '200' then
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMFL_STATUS_SENDING;
SERR := null;
else
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMFL_STATUS_SEND_ERR;
SERR := SMESSAGE;
end case;
for RCMLF in (select T.RN from UDO_T_EQUIPDSCMFL T where t.dataset_id = REXSQUEUE.LNK_DOCUMENT)loop
/* Базовая установка состояния "Выборки данных оборудования (классы оборудования, файлы данных)" */
UDO_PKG_EQUIPDS_BASE.CMFL_SET_STATUS(NRN => RCMLF.RN,
NSTATUS => NSTATUS,
SQUEUE_ID => SQUEUE_ID,
SERR => SERR);
end loop;
/* Возвращаем ответ */
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_OK);
exception
when others then
/* Вернём ошибку - это фатальная */
PKG_STATE.DIAGNOSTICS_STACKED();
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_ERR,
SMSG => PKG_STATE.SQL_ERRM());
end P_METADATA;
/* Обработка передачи Фреймворку запроса на обучение модели */
procedure P_REQUIREMENTS
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
)
is
REXSQUEUE EXSQUEUE%ROWTYPE; -- заить очереди обмена
SSTATE PKG_STD.tSTRING; -- Код состояния отработки 200- успех; 500 - ошибка
SMESSAGE PKG_STD.tSTRING; -- Текст ошибки
NSTATUS PKG_STD.tNUMBER; -- состояния "Выборки данных оборудования (классы оборудования, файлы данных)"
SERR PKG_STD.tSTRING; -- Текст ошибки
SSTATESP PKG_STD.tSTRING; -- Статус обработки запроса
SQUEUE_ID PKG_STD.tSTRING; -- Идентификатор полуеный от стороннего сервера
begin
/* Поиск записи очереди обмена */
REXSQUEUE := GET_EXSQUEUE_ID(NFLAG_SMART => 0, NRN => NEXSQUEUE);
/* Читаем статус запроса */
SSTATE := PKG_EXS.OPTIONS_READ(sOPTIONS => REXSQUEUE.OPTIONS_RESP,
SPATH => 'statusCode');
SMESSAGE := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(REXSQUEUE.RESP, PKG_CHARSET.CHARSET_UTF_),
SPATH => 'message');
SQUEUE_ID := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(REXSQUEUE.RESP, PKG_CHARSET.CHARSET_UTF_),
SPATH => 'queue_id');
SSTATESP := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.RESP,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'status');
/* Обработка статуса отпраки и контроль резульатат */
case SSTATE
when '200' then
case UPPER(SSTATESP)
when 'OK' then
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMML_STATUS_PROCESSING;
SERR := null;
else
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMML_STATUS_PROCESS_ERR;
SERR := SMESSAGE;
end case;
else
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMML_STATUS_PROCESS_ERR;
SERR := 'Ошибка при передаче запроса, код: '||SSTATE;
end case;
for RCMLF in (select T.RN from UDO_T_EQUIPDSCMML T where T.RN = REXSQUEUE.LNK_DOCUMENT)loop
/* Базовая установка состояния "Выборки данных оборудования (классы оборудования, модели)" */
UDO_PKG_EQUIPDS_BASE.CMML_SET_STATUS(NRN => RCMLF.RN,
NSTATUS => NSTATUS,
SQUEUE_ID => SQUEUE_ID,
SERR => SERR);
end loop;
/* Возвращаем ответ */
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_OK);
exception
when others then
/* Вернём ошибку - это фатальная */
PKG_STATE.DIAGNOSTICS_STACKED();
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_ERR,
SMSG => PKG_STATE.SQL_ERRM());
end P_REQUIREMENTS;
/* Обработка получения состояния загрузки данных Фреймворком*/
procedure P_METADATA_CB
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
)
is
REXSQUEUE EXSQUEUE%ROWTYPE; -- заить очереди обмена
SSTATE PKG_STD.tSTRING; -- Код состояния отработки 200- успех; 500 - ошибка
SMESSAGE PKG_STD.tSTRING; -- Текст ошибки
NSTATUS PKG_STD.tNUMBER; -- состояния "Выборки данных оборудования (классы оборудования, файлы данных)"
SERR PKG_STD.tSTRING; -- Текст ошибки
SQUEUE_ID PKG_STD.tSTRING; -- Идентификатор очереди обработки
begin
/* Поиск записи очереди обмена */
REXSQUEUE := GET_EXSQUEUE_ID(NFLAG_SMART => 0, NRN => NEXSQUEUE);
/* Читаем статус запроса */
SSTATE := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'status');
/* Читаем сообщение запроса */
SMESSAGE := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'message');
/* Читаем идентификатор запроса */
SQUEUE_ID := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'queue_id');
case UPPER(SSTATE)
when 'OK' then
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMFL_STATUS_SENT;
SERR := null;
else
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMFL_STATUS_SEND_ERR;
SERR := SMESSAGE;
end case;
for RCMLF in (select T.RN from UDO_T_EQUIPDSCMFL T where t.queue_id = SQUEUE_ID)loop
/* Базовая установка состояния "Выборки данных оборудования (классы оборудования, файлы данных)" */
UDO_PKG_EQUIPDS_BASE.CMFL_SET_STATUS(NRN => RCMLF.RN,
NSTATUS => NSTATUS,
SQUEUE_ID => SQUEUE_ID, -- ПЕРЕДЕЛАТЬ !!!! Стичать значение из отета сервера!!!!!
SERR => SERR);
end loop;
/* Возвращаем ответ */
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_OK);
exception
when others then
/* Вернём ошибку - это фатальная */
PKG_STATE.DIAGNOSTICS_STACKED();
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_ERR,
SMSG => PKG_STATE.SQL_ERRM());
end P_METADATA_CB;
/* Обработка получение состояния обучения модели Фреймворком */
procedure P_REQUIREMENTS_CB
(
NIDENT in number, -- Идентификатор процесса
NEXSQUEUE in number -- Регистрационный номер обрабатываемой позиции очереди обмена
)
is
REXSQUEUE EXSQUEUE%ROWTYPE; -- заить очереди обмена
SSTATE PKG_STD.tSTRING; -- Код состояния отработки 200- успех; 500 - ошибка
SMESSAGE PKG_STD.tSTRING; -- Текст ошибки
NSTATUS PKG_STD.tNUMBER; -- состояния "Выборки данных оборудования (классы оборудования, файлы данных)"
SERR PKG_STD.tSTRING; -- Текст ошибки
SQUEUE_ID PKG_STD.tSTRING; -- Идентификатор очереди обработки
NPRECISION_F PKG_STD.tNUMBER; -- Точность Модели (факт)
begin
/* Поиск записи очереди обмена */
REXSQUEUE := GET_EXSQUEUE_ID(NFLAG_SMART => 0, NRN => NEXSQUEUE);
/* Читаем статус запроса */
SSTATE := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'status');
SMESSAGE := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'message');
SQUEUE_ID := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'queue_id');
NPRECISION_F := PKG_EXS.OPTIONS_READ(sOPTIONS => BLOB2CLOB(lbDATA => REXSQUEUE.MSG,
sCHARSET => PKG_CHARSET.CHARSET_UTF_),
SPATH => 'precision');
case UPPER(SSTATE)
when 'OK' then
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMML_STATUS_PROCESSED;
SERR := null;
else
NSTATUS := UDO_PKG_EQUIPDS_BASE.NCMML_STATUS_PROCESS_ERR;
SERR := SMESSAGE;
end case;
for RCMML in (select T.RN from UDO_T_EQUIPDSCMML T where t.queue_id = SQUEUE_ID)loop
/* Базовая установка состояния "Выборки данных оборудования (классы оборудования, файлы данных)" */
UDO_PKG_EQUIPDS_BASE.CMML_SET_STATUS(NRN => RCMML.RN,
NSTATUS => NSTATUS,
SQUEUE_ID => SQUEUE_ID,
SERR => SERR);
if SERR is null then
/* Базовая установка фактической точности "Выборки данных оборудования (классы оборудования, модели)" */
UDO_PKG_EQUIPDS_BASE.CMML_SET_PRECISION_F(NRN => RCMML.RN, NPRECISION_F => ROUND(NPRECISION_F,0));
end if;
end loop;
/* Возвращаем ответ */
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_OK);
exception
when others then
/* Вернём ошибку - это фатальная */
PKG_STATE.DIAGNOSTICS_STACKED();
PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT,
SRESULT => PKG_EXS.SPRC_RESP_RESULT_ERR,
SMSG => PKG_STATE.SQL_ERRM());
end P_REQUIREMENTS_CB;
/* Инициализация настроек расширения для интеграции с фреймворк по прогнозированию ресурса оборудования */
procedure INIT_EQUIPDS
(
NCRN in number, -- Рег. номер каталога сервиса обмена
NFORCE_UPDATE in number -- Обновлять существующие записи (см. константы PKG_EXS.NFORCE_UPDATE_*)
)
is
NEXSMSGTYPE PKG_STD.TREF; -- Рег. номер записи типовых сообщений обмена
NEXSSERVICE PKG_STD.TREF; -- Рег. номер записи сервиса обмена
NEXSSERVICEFN PKG_STD.TREF; -- Рег. номер записи функции сервиса обмена
begin
/* Загрузка типового сообщения обмена */
P_EXSMSGTYPE_BASE_LOAD(SCATALOG => null,
SCODE => SEQUIPDS_MSGTYPE_CODE_LSCP,
SNAME => SEQUIPDS_MSGTYPE_NAME_LSCP,
SPKG_RESP => SEQUIPDS_MSGTYPE_PKG_LSCP,
SPRC_RESP => SEQUIPDS_MSGTYPE_PRC_LSCP,
SAPPSRV_BEFORE => SEQUIPDS_MSGTYPE_SRVBFR_LSCP,
SAPPSRV_AFTER => null,
NMAX_IDLE => 0,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSMSGTYPE);
P_EXSMSGTYPE_BASE_LOAD(SCATALOG => null,
SCODE => SEQUIPDS_MSGTYPE_CODE_LFRM,
SNAME => SEQUIPDS_MSGTYPE_NAME_LFRM,
SPKG_RESP => SEQUIPDS_MSGTYPE_PKG_LFRM,
SPRC_RESP => SEQUIPDS_MSGTYPE_PRC_LFRM,
SAPPSRV_BEFORE => SEQUIPDS_MSGTYPE_SRVBFR_LFRM,
SAPPSRV_AFTER => SEQUIPDS_MSGTYPE_SRVAFTR_LFRM,
NMAX_IDLE => 0,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSMSGTYPE);
P_EXSMSGTYPE_BASE_LOAD(SCATALOG => null,
SCODE => SEQUIPDS_MSGTYPE_CODE_RQLRN,
SNAME => SEQUIPDS_MSGTYPE_NAME_RQLRN,
SPKG_RESP => SEQUIPDS_MSGTYPE_PKG_RQLRN,
SPRC_RESP => SEQUIPDS_MSGTYPE_PRC_RQLRN,
SAPPSRV_BEFORE => SEQUIPDS_MSGTYPE_SRVBFR_RQLRN,
SAPPSRV_AFTER => SEQUIPDS_MSGTYPE_SRVAFTR_RQLRN,
NMAX_IDLE => 0,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSMSGTYPE);
P_EXSMSGTYPE_BASE_LOAD(SCATALOG => null,
SCODE => SEQUIPDS_MSGTYPE_CODE_MTCB,
SNAME => SEQUIPDS_MSGTYPE_NAME_MTCB,
SPKG_RESP => SEQUIPDS_MSGTYPE_PKG_MTCB,
SPRC_RESP => SEQUIPDS_MSGTYPE_PRC_MTCB,
SAPPSRV_BEFORE => SEQUIPDS_MSGTYPE_SRVBFR_MTCB,
SAPPSRV_AFTER => null,
NMAX_IDLE => 0,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSMSGTYPE);
P_EXSMSGTYPE_BASE_LOAD(SCATALOG => null,
SCODE => SEQUIPDS_MSGTYPE_CODE_REQCB,
SNAME => SEQUIPDS_MSGTYPE_NAME_REQCB,
SPKG_RESP => SEQUIPDS_MSGTYPE_PKG_REQCB,
SPRC_RESP => SEQUIPDS_MSGTYPE_PRC_REQCB,
SAPPSRV_BEFORE => SEQUIPDS_MSGTYPE_SRVBFR_REQCB,
SAPPSRV_AFTER => null,
NMAX_IDLE => 0,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSMSGTYPE);
/* Загрузка сервиса обмена */
P_EXSSERVICE_BASE_LOAD(SCATALOG => GET_ACATALOG_NAME_ID(NFLAG_SMART => 0, NRN => NCRN),
SCODE => SEQUIPDS_SRVC_CODE_LSCP,
SNAME => SEQUIPDS_SRVC_NAME_LSCP,
NSRV_TYPE => NEQUIPDS_SRVC_SRV_TYPE_LSCP,
SSRV_ROOT => SEQUIPDS_SRVC_SRV_ROOT_LSCP,
SSRV_USER => null,
SSRV_PASS => null,
NUNAVLBL_NTF_SIGN => PKG_EXS.NUNAVLBL_NTF_SIGN_NO,
NUNAVLBL_NTF_TIME => 0,
SUNAVLBL_NTF_MAIL => null,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSSERVICE);
/* Загрузка функции сервиса обмена */
P_EXSSERVICEFN_BASE_LOAD(NPRN => NEXSSERVICE,
SCODE => SEQUIPDS_SRVCFN_CODE_LSCP,
SNAME => SEQUIPDS_SRVCFN_NAME_LSCP,
NFN_TYPE => NEQUIPDS_SRVCFN_FN_TYPE_LSCP,
SFN_URL => SEQUIPDS_SRVCFN_FN_URL_LSCP,
NFN_PRMS_TYPE => NEQUIPDS_SRVCFN_FNPRMS_TP_LSCP,
NRETRY_SCHEDULE => PKG_EXS.NRETRY_SCHEDULE_UNDEF,
NRETRY_STEP => 0,
NRETRY_ATTEMPTS => 0,
SEXSMSGTYPE => SEQUIPDS_MSGTYPE_CODE_LSCP,
NERR_NTF_SIGN => PKG_EXS.NERR_NTF_SIGN_NO,
SERR_NTF_MAIL => null,
NAUTH_ONLY => PKG_EXS.NAUTH_ONLY_NO,
NSAVE_QUEUE => PKG_EXS.NFN_SAVE_QUEUE,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSSERVICEFN);
/* Загрузка сервиса обмена */
P_EXSSERVICE_BASE_LOAD(SCATALOG => GET_ACATALOG_NAME_ID(NFLAG_SMART => 0, NRN => NCRN),
SCODE => SEQUIPDS_SRVC_CODE_LFRM,
SNAME => SEQUIPDS_SRVC_NAME_LFRM,
NSRV_TYPE => NEQUIPDS_SRVC_SRV_TYPE_LFRM,
SSRV_ROOT => SEQUIPDS_SRVC_SRV_ROOT_LFRM,
SSRV_USER => null,
SSRV_PASS => null,
NUNAVLBL_NTF_SIGN => PKG_EXS.NUNAVLBL_NTF_SIGN_NO,
NUNAVLBL_NTF_TIME => 0,
SUNAVLBL_NTF_MAIL => null,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSSERVICE);
/* Загрузка функции сервиса обмена */
P_EXSSERVICEFN_BASE_LOAD(NPRN => NEXSSERVICE,
SCODE => SEQUIPDS_SRVCFN_CODE_LFRM,
SNAME => SEQUIPDS_SRVCFN_NAME_LFRM,
NFN_TYPE => NEQUIPDS_SRVCFN_FN_TYPE_LFRM,
SFN_URL => SEQUIPDS_SRVCFN_FN_URL_LFRM,
NFN_PRMS_TYPE => NEQUIPDS_SRVCFN_FNPRMS_TP_LFRM,
NRETRY_SCHEDULE => PKG_EXS.NRETRY_SCHEDULE_UNDEF,
NRETRY_STEP => 0,
NRETRY_ATTEMPTS => 0,
SEXSMSGTYPE => SEQUIPDS_MSGTYPE_CODE_LFRM,
NERR_NTF_SIGN => PKG_EXS.NERR_NTF_SIGN_NO,
SERR_NTF_MAIL => null,
NAUTH_ONLY => PKG_EXS.NAUTH_ONLY_NO,
NSAVE_QUEUE => PKG_EXS.NFN_SAVE_QUEUE,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSSERVICEFN);
/* Загрузка функции сервиса обмена */
P_EXSSERVICEFN_BASE_LOAD(NPRN => NEXSSERVICE,
SCODE => SEQUIPDS_SRVCFN_CODE_RQLRN,
SNAME => SEQUIPDS_SRVCFN_NAME_RQLRN,
NFN_TYPE => NEQUIPDS_SRVCFN_FN_TYPE_RQLRN,
SFN_URL => SEQUIPDS_SRVCFN_FN_URL_RQLRN,
NFN_PRMS_TYPE => NEQUIPDS_SRVCFN_FNPR_TP_RQLRN,
NRETRY_SCHEDULE => PKG_EXS.NRETRY_SCHEDULE_UNDEF,
NRETRY_STEP => 0,
NRETRY_ATTEMPTS => 0,
SEXSMSGTYPE => SEQUIPDS_MSGTYPE_CODE_RQLRN,
NERR_NTF_SIGN => PKG_EXS.NERR_NTF_SIGN_NO,
SERR_NTF_MAIL => null,
NAUTH_ONLY => PKG_EXS.NAUTH_ONLY_NO,
NSAVE_QUEUE => PKG_EXS.NFN_SAVE_QUEUE,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSSERVICEFN);
/* Загрузка сервиса обмена */
P_EXSSERVICE_BASE_LOAD(SCATALOG => GET_ACATALOG_NAME_ID(NFLAG_SMART => 0, NRN => NCRN),
SCODE => SEQUIPDS_SRVC_CODE_CLLBCK,
SNAME => SEQUIPDS_SRVC_NAME_CLLBCK,
NSRV_TYPE => NEQUIPDS_SRVC_SRV_TYPE_CLLBCK,
SSRV_ROOT => SEQUIPDS_SRVC_SRV_ROOT_CLLBCK,
SSRV_USER => null,
SSRV_PASS => null,
NUNAVLBL_NTF_SIGN => PKG_EXS.NUNAVLBL_NTF_SIGN_NO,
NUNAVLBL_NTF_TIME => 0,
SUNAVLBL_NTF_MAIL => null,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSSERVICE);
/* Загрузка функции сервиса обмена */
P_EXSSERVICEFN_BASE_LOAD(NPRN => NEXSSERVICE,
SCODE => SEQUIPDS_SRVCFN_CODE_MTCB,
SNAME => SEQUIPDS_SRVCFN_NAME_MTCB,
NFN_TYPE => NEQUIPDS_SRVCFN_FN_TYPE_MTCB,
SFN_URL => SEQUIPDS_SRVCFN_FN_URL_MTCB,
NFN_PRMS_TYPE => NEQUIPDS_SRVCFN_FNPRMS_TP_MTCB,
NRETRY_SCHEDULE => PKG_EXS.NRETRY_SCHEDULE_UNDEF,
NRETRY_STEP => 0,
NRETRY_ATTEMPTS => 0,
SEXSMSGTYPE => SEQUIPDS_MSGTYPE_CODE_MTCB,
NERR_NTF_SIGN => PKG_EXS.NERR_NTF_SIGN_NO,
SERR_NTF_MAIL => null,
NAUTH_ONLY => PKG_EXS.NAUTH_ONLY_NO,
NSAVE_QUEUE => PKG_EXS.NFN_SAVE_QUEUE,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSSERVICEFN);
/* Загрузка функции сервиса обмена */
P_EXSSERVICEFN_BASE_LOAD(NPRN => NEXSSERVICE,
SCODE => SEQUIPDS_SRVCFN_CODE_REQCB,
SNAME => SEQUIPDS_SRVCFN_NAME_REQCB,
NFN_TYPE => NEQUIPDS_SRVCFN_FN_TYPE_REQCB,
SFN_URL => SEQUIPDS_SRVCFN_FN_URL_REQCB,
NFN_PRMS_TYPE => NEQUIPDS_SRVCFN_FNPR_TP_REQCB,
NRETRY_SCHEDULE => PKG_EXS.NRETRY_SCHEDULE_UNDEF,
NRETRY_STEP => 0,
NRETRY_ATTEMPTS => 0,
SEXSMSGTYPE => SEQUIPDS_MSGTYPE_CODE_REQCB,
NERR_NTF_SIGN => PKG_EXS.NERR_NTF_SIGN_NO,
SERR_NTF_MAIL => null,
NAUTH_ONLY => PKG_EXS.NAUTH_ONLY_NO,
NSAVE_QUEUE => PKG_EXS.NFN_SAVE_QUEUE,
NFORCE_UPDATE => NFORCE_UPDATE,
NRN => NEXSSERVICEFN);
end INIT_EQUIPDS;
end UDO_PKG_EQUIPDS_EXS;
/

434
db/UDO_PKG_EQUIPDS_SEND.pck Normal file
View File

@ -0,0 +1,434 @@
create or replace package UDO_PKG_EQUIPDS_SEND
is
/*
Описание: Обеспечивает формироание и отправку тела запроса.
Проект: Интеграция ПП «Парус 8» и «Фреймворка оценки и прогнозирования состояния оборудования»
Разработчик: ЦИТК-ПАРУС
Отественный: Селианов А.Е.
Дата последнего изменения: 24.03.2025
*/
/* Константы */
SDEF_SEND_POINT_PRM constant PKG_STD.tSTRING := 'EXSService_AppServer'; -- Адрес сервера приложений (сервисы обмена)
/* отправка запроса */
procedure SEND_PACKGE
(
NEXSSERVICEFN in number, -- Рег. номер функции обработки
NLNK_NEXSQUEUE in number default null, -- Рег.номер сязанной очереди
NCOMPANY in number := null, -- Рег. номер связанной организации
NDOCUMENT in number := null, -- Рег. номер связанной записи документа
SUNITCODE in varchar2 := null, -- Код связанного раздела
SHOST in varchar2 := null, -- host
SPORT in varchar2 := null, -- port
SUSER in varchar2 := null, -- username
SPASS in varchar2 := null, -- password
bAUTH in boolean := false, -- Требуется авторизация
SPATCH_LOKAL in varchar2 := null, -- Путь размещения файла на локальном сервере
NEQUIPDSCMN in number := null, -- Рег. номер класса оборудования выборки данных
SPATCH_FSERV in varchar2 := null, -- Путь размещения файла на сервере CSP
SDESCR in varchar2 := null, -- Описание выборки данных
NPRIORITY in number default 0, -- Приоритет (0- поумолчанию; 100- наиысший приоритет)
BMSG in blob -- Загружаемый XML с данными запроса в СКУД;
);
/* Подготока данных для Загрузки файла на SCP */
procedure SCP_DATA_MAKE
(
NEXSSERVICEFN in number, -- Рег. номер функции обработки
SHOST out varchar2, -- host
SPORT out varchar2, -- port
SUSER out varchar2, -- username
SPASS out varchar2, -- password
--SPATCH_LOKAL out varchar2, -- Путь размещения файла на локальном сервере
SPATCH_FSERV out varchar2 -- Путь размещения файла на сервере CSP
);
/* Подготока данных для Загрузки файла на Фреймворк */
procedure AUTH_DATA_MAKE
(
NEXSSERVICEFN in number, -- Рег. номер функции обработки
sAUTH out varchar2 -- Данные авторизции ("Authorization Basic base64(login:pass))
);
/* Подготока данных для для передачи внешней системе */
procedure METADATA_MAKE
(
NIDENT in number, -- Идентификатор Selectlis
NEQUIPDSCM in number, -- регистрационный номер записи Выборки данных класса оборудования»
NDATASET_ID out number, -- DATASET_ID
BXML out blob -- Тело файла
);
/* Подготока данных для передачи Фреймворку запроса на обучение модели */
procedure REQUIREMENTS_MAKE
(
NEQUIPDSCMML in number, -- регистрационный номер записи Выборки Модели»
BXML out blob -- Тело файла
);
end UDO_PKG_EQUIPDS_SEND;
/
create or replace package body UDO_PKG_EQUIPDS_SEND
is
/* Получение URL для обработки результата */
function GET_URL_END_POINT
(
NEXSSERVICEFN in varchar2 -- Мнемокод функции сервиса обмена
)return varchar2 -- URL для обработки результата
is
REXSSERVICEFN EXSSERVICEFN%rowtype; --
REXSSERVICE EXSSERVICE%rowtype; -- Запись сервиса обмена
SURL PKG_STD.tSTRING; -- Адрес сервера приложений (сервисы обмена)
begin
/* Считывание записи функции сервиса обмена */
REXSSERVICEFN := GET_EXSSERVICEFN_ID(NFLAG_SMART => 0, NRN => NEXSSERVICEFN);
/* Считывание записи сервиса обмена */
REXSSERVICE := GET_EXSSERVICE_ID(NFLAG_SMART => 0, NRN => REXSSERVICEFN.PRN);
/*Считывание параметра - Адрес сервера приложений (сервисы обмена)*/
SURL := get_options_str(sCODE => SDEF_SEND_POINT_PRM, nCOMP_VERS => null );
/* Формирование полного URL END_POINT */
SURL := SURL||REXSSERVICE.SRV_ROOT||'/'||REXSSERVICEFN.FN_URL;
return SURL;
end GET_URL_END_POINT;
/* отправка запроса */
procedure SEND_PACKGE
(
NEXSSERVICEFN in number, -- Рег. номер функции обработки
NLNK_NEXSQUEUE in number default null, -- Рег.номер сязанной очереди
NCOMPANY in number := null, -- Рег. номер связанной организации
NDOCUMENT in number := null, -- Рег. номер связанной записи документа
SUNITCODE in varchar2 := null, -- Код связанного раздела
SHOST in varchar2 := null, -- host
SPORT in varchar2 := null, -- port
SUSER in varchar2 := null, -- username
SPASS in varchar2 := null, -- password
bAUTH in boolean := false, -- Требуется авторизация
SPATCH_LOKAL in varchar2 := null, -- Путь размещения файла на локальном сервере
NEQUIPDSCMN in number := null, -- Рег. номер класса оборудования выборки данных
SPATCH_FSERV in varchar2 := null, -- Путь размещения файла на сервере CSP
SDESCR in varchar2 := null, -- Описание выборки данных
NPRIORITY in number default 0, -- Приоритет (0- поумолчанию; 100- наиысший приоритет)
BMSG in blob -- Загружаемый XML с данными запроса в СКУД;
)
is
NQ PKG_STD.TREF; -- Рег. номер очереди обмена
OPTS PKG_EXS.TOPTIONS; -- Параметры запроса
HDR_HEADERS PKG_EXS.TOPTIONS; -- Заголоок запроса
sAUTH PKG_STD.tLSTRING; -- Строка аторизации
begin
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'NEXSSERVICEFN',
SVALUE => NEXSSERVICEFN);
if SHOST is not null then
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'SHOST_SCP',
SVALUE => SHOST);
end if;
if SPORT is not null then
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'SPORT_SCP',
SVALUE => SPORT);
end if;
if SUSER is not null then
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'SUSER_SCP',
SVALUE => SUSER);
end if;
if SPASS is not null then
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'SPASS_SCP',
SVALUE => SPASS);
end if;
if (bAUTH) then
AUTH_DATA_MAKE(NEXSSERVICEFN => NEXSSERVICEFN, sAUTH => sAUTH);
if sAUTH is not null then
/* authorization */
PKG_EXS.OPTIONS_SET(OPTIONS => HDR_HEADERS,
SCODE => pkg_exs.SHTP_HDR_AUTHORIZATION,
SVALUE => sAUTH);
PKG_EXS.OPTIONS_SET(OPTIONS => HDR_HEADERS,
SCODE => pkg_exs.SHTP_HDR_CNT_TP,
SVALUE => pkg_exs.SHTP_HDR_CNT_TP_JSON);
end if;
end if;
if SPATCH_LOKAL is not null then
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'SPATCH_LOCAL',
SVALUE => SPATCH_LOKAL);
end if;
if NEQUIPDSCMN is not null then
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'NEQUIPDSCMN',
SVALUE => NEQUIPDSCMN);
end if;
if SPATCH_FSERV is not null then
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'SPATCH_FSERV',
SVALUE => SPATCH_FSERV);
end if;
if SDESCR is not null then
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => 'SDESCR',
SVALUE => SDESCR);
end if;
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => PKG_EXS.SMSG_OPTION_CODE_SIMPLE,
SVALUE => PKG_EXS.SMSG_OPTION_SIMPLE_FALSE);
/* Формируем параметры запроса */
PKG_EXS.OPTIONS_SET(OPTIONS => OPTS,
SCODE => pkg_exs.SMSG_OPTION_CODE_HEADERS,
SVALUE => PKG_EXS.OPTIONS_SERIALIZE(OPTIONS => HDR_HEADERS,
BROOT => false));
/* Постанока запроса в очередь */
PKG_EXS.QUEUE_PUT(NEXSSERVICEFN => NEXSSERVICEFN,
BMSG => BMSG,
NEXSQUEUE => NLNK_NEXSQUEUE,
NLNK_COMPANY => nCOMPANY,
NLNK_DOCUMENT => NDOCUMENT,
SLNK_UNITCODE => SUNITCODE,
SOPTIONS => PKG_EXS.OPTIONS_SERIALIZE(OPTIONS => OPTS),
NPRIORITY => NPRIORITY,
NNEW_EXSQUEUE => NQ);
end SEND_PACKGE;
/* Подготока данных для Загрузки файла на SCP */
procedure SCP_DATA_MAKE
(
NEXSSERVICEFN in number, -- Рег. номер функции обработки
SHOST out varchar2, -- host
SPORT out varchar2, -- port
SUSER out varchar2, -- username
SPASS out varchar2, -- password
SPATCH_FSERV out varchar2 -- Путь размещения файла на сервере CSP
)
is
REXSSERVICEFN EXSSERVICEFN%rowtype; --
REXSSERVICE EXSSERVICE%rowtype; -- Запись сервиса обмена
begin
/* Считывание записи функции сервиса обмена */
REXSSERVICEFN := GET_EXSSERVICEFN_ID(NFLAG_SMART => 0, NRN => NEXSSERVICEFN);
/* Считывание записи сервиса обмена */
REXSSERVICE := GET_EXSSERVICE_ID(NFLAG_SMART => 0, NRN => REXSSERVICEFN.PRN);
/**/
SHOST := REGEXP_SUBSTR(REGEXP_SUBSTR(REXSSERVICE.SRV_ROOT,'(.*?)(//|$)', 1,2,NULL,1),'(.*?)(:|$)', 1,1,NULL,1);
SPORT := REGEXP_SUBSTR(REGEXP_SUBSTR(REXSSERVICE.SRV_ROOT,'(.*?)(//|$)', 1,2,NULL,1),'(.*?)(:|$)', 1,2,NULL,1);
/* Считаем параметры пользователя логин и пароль */
SUSER := REXSSERVICE.SRV_USER;
SPASS := BLOB2CLOB(lbDATA => BASE64_DECODE(REXSSERVICE.SRV_PASS),sCHARSET => PKG_CHARSET.CHARSET_UTF_);
/**/
SPATCH_FSERV := REXSSERVICEFN.FN_URL;
end SCP_DATA_MAKE;
/* Подготока данных для Загрузки файла на Фреймворк */
procedure AUTH_DATA_MAKE
(
NEXSSERVICEFN in number, -- Рег. номер функции обработки
sAUTH out varchar2 -- Данные авторизции ("Authorization Basic base64(login:pass))
)
is
REXSSERVICEFN EXSSERVICEFN%rowtype; -- Запись функции сервиса обмена
REXSSERVICE EXSSERVICE%rowtype; -- Запись сервиса обмена
SUSER PKG_STD.tSTRING; -- username
SPASS PKG_STD.tSTRING; -- password
begin
/* Считывание записи функции сервиса обмена */
REXSSERVICEFN := GET_EXSSERVICEFN_ID(NFLAG_SMART => 0, NRN => NEXSSERVICEFN);
/* Считывание записи сервиса обмена */
REXSSERVICE := GET_EXSSERVICE_ID(NFLAG_SMART => 0, NRN => REXSSERVICEFN.PRN);
/* Считаем параметры пользователя логин и пароль */
SUSER := REXSSERVICE.SRV_USER;
SPASS := BLOB2CLOB(lbDATA => BASE64_DECODE(REXSSERVICE.SRV_PASS),sCHARSET => PKG_CHARSET.CHARSET_UTF_);
/**/
sAUTH := 'Basic'||' '||BASE64_ENCODE(lbSRCE => CLOB2BLOB(lcDATA => SUSER||':'||SPASS,sCHARSET => PKG_CHARSET.CHARSET_UTF_));
end AUTH_DATA_MAKE;
/* Подготока данных для для передачи внешней системе */
procedure METADATA_MAKE
(
NIDENT in number, -- Идентификатор Selectlis
NEQUIPDSCM in number, -- регистрационный номер записи Выборки данных класса оборудования»
NDATASET_ID out number, -- DATASET_ID
BXML out blob -- Тело файла
)
is
SEND_POINT PKG_STD.tSTRING; -- URL для обработки результата
xNODE PKG_XMAKE.tNODE; -- Подчиненный узел
xNODE_FL PKG_XMAKE.tNODE; -- Подчиненный узел Имён файлов
XDOC integer; -- Документ для размещения XML-элемента
DATACONFIG PKG_XMAKE.tNODE; -- DATACONFIG
ATRIBS PKG_XMAKE.tATTRIBUTES; -- Атрибуты
RDOCUMENT PKG_XPATH.TDOCUMENT; -- XML документ
RROOT PKG_XPATH.TNODE; -- Корневой узел XML документа
FIRSTNODE PKG_XPATH.TNODE; -- Корневой узел XML документа
RNODE PKG_XPATH.TNODE; --
RNODES PKG_XPATH.TNODES; -- Узлы XML документа
NCURS_COUNT PKG_STD.tNUMBER; -- Количество узлов
BONLYONE boolean := true;
begin
XDOC := PKG_XMAKE.OPEN_CURSOR();
for REQUIPDSCM in (select E.CODE SEQOBJKIND, t.* from UDO_T_EQUIPDSCM T, EQOBJKIND E where T.RN = NEQUIPDSCM and T.EQOBJKIND = E.RN)loop
RDOCUMENT := PKG_XPATH.PARSE_FROM_CLOB(REQUIPDSCM.DATA_CONFIG);
RROOT := PKG_XPATH.ROOT_NODE(RDOCUMENT);
FIRSTNODE := PKG_XPATH.FIRST_NODE(RROOT);
RNODES := PKG_XPATH.LIST_NODES(FIRSTNODE, 'item');
NCURS_COUNT := PKG_XPATH.COUNT_NODES(RNODES);
for I in 1 .. NCURS_COUNT loop
RNODE := PKG_XPATH.ITEM_NODE(RNODES, I);
ATRIBS := PKG_XMAKE.ATTRIBUTES(iCURSOR => XDOC,
rATTRIBUTE00 => PKG_XMAKE.ATTRIBUTE(iCURSOR => XDOC,sNAME => 'col_name',sVALUE => PKG_XPATH.ATTRIBUTE(RNODE, 'col_code')),
rATTRIBUTE01 => PKG_XMAKE.ATTRIBUTE(iCURSOR => XDOC,sNAME => 'data_type',sVALUE => PKG_XPATH.ATTRIBUTE(RNODE, 'data_type'))
);
DATACONFIG := PKG_XMAKE.CONCAT(iCURSOR => XDOC,
rNODE00 => DATACONFIG,
rNODE01 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,sNAME => 'data_config',rATTRIBUTES => ATRIBS)
);
end loop;
PKG_XPATH.FREE(rDOCUMENT => RDOCUMENT);
/* Сформируем полный URL */
SEND_POINT := GET_URL_END_POINT(NEXSSERVICEFN => REQUIPDSCM.EXSSERVICEFN_SEND_MDCB);
/* Перечень файлов */
for REQUIPDSCMFL in (select FL.* from UDO_T_EQUIPDSCMFL FL, SELECTLIST SL Where FL.RN = SL.DOCUMENT and SL.IDENT = NIDENT)loop
/* Идентификатор dataset */
if (BONLYONE) then
xNODE := PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'dataset_ID',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => REQUIPDSCMFL.DATASET_ID));
BONLYONE := false;
NDATASET_ID := REQUIPDSCMFL.DATASET_ID;
end if;
xNODE_FL := PKG_XMAKE.CONCAT(iCURSOR => XDOC,
rNODE00 => xNODE_FL,
rNODE01 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'ftp_filepath',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => REQUIPDSCMFL.FILE_NAME)));
end loop;
xNODE := PKG_XMAKE.CONCAT(iCURSOR => XDOC,
rNODE00 => xNODE,
/* Тип оборудования */
rNODE01 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'class_machine',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => TRIM(REQUIPDSCM.SEQOBJKIND))),
rNODE02 => xNODE_FL,
/* url для результата отпраки */
rNODE03 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'end_point',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => SEND_POINT)),
/* Описание полей dataset */
rNODE04 => DATACONFIG
);
end loop;
BXML := PKG_XMAKE.SERIALIZE_TO_BLOB(iCURSOR => XDOC,
iTYPE => PKG_XMAKE.DOCUMENT_,
rNODE => PKG_XMAKE.CONCAT(iCURSOR => XDOC,
rNODE00 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'root',
rNODE00 => xNODE)),
rHEADER => PKG_XHEADER.WRAP_ALL(PKG_XHEADER.VERSION_1_0_,
PKG_XHEADER.ENCODING_UTF_,
PKG_XHEADER.STANDALONE_NONE_)
);
PKG_XMAKE.CLOSE_CURSOR(iCURSOR => XDOC);
end METADATA_MAKE;
/* Подготока данных для передачи Фреймворку запроса на обучение модели */
procedure REQUIREMENTS_MAKE
(
NEQUIPDSCMML in number, -- регистрационный номер записи Выборки Модели»
BXML out blob -- Тело файла
)
is
SEND_POINT PKG_STD.tSTRING; -- URL для обработки результата
xNODE PKG_XMAKE.tNODE; -- Подчиненный узел
xNODE_ML PKG_XMAKE.tNODE; -- Подчиненный узел обучение модели
XDOC integer; -- Документ для размещения XML-элемента
BONLYONE boolean := true;
begin
/*Старт сборки XML*/
XDOC := PKG_XMAKE.OPEN_CURSOR();
/* Перечень файлов */
for REQUIPDSCMML in (select M.EQOBJKIND,
M.EXSSERVICEFN_SEND_RQCB,
TRIM(E.CODE) SEQOBJKIND,
ML.*
from UDO_T_EQUIPDSCMML ML,
UDO_T_EQUIPDSCM M,
EQOBJKIND E
Where ML.RN = NEQUIPDSCMML
and ML.PRN = M.RN
and M.EQOBJKIND = E.RN) loop
/* Сформируем полный URL */
if (BONLYONE) then
SEND_POINT := GET_URL_END_POINT(NEXSSERVICEFN => REQUIPDSCMML.EXSSERVICEFN_SEND_RQCB);
BONLYONE := false;
end if;
/* Ссобирем узел запроса */
xNODE_ML := PKG_XMAKE.CONCAT(iCURSOR => XDOC,
rNODE00 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'dataset_ID',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => REQUIPDSCMML.DATASET_ID)),
rNODE01 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'task',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => REQUIPDSCMML.TASK)),
rNODE02 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'precision',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => 100)));
/* Ссобирем узел запроса */
xNODE := PKG_XMAKE.CONCAT(iCURSOR => XDOC,
rNODE00 => xNODE_ML,
/* Тип оборудования */
rNODE01 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'class_machine',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => REQUIPDSCMML.SEQOBJKIND)),
/* url для результата отпраки */
rNODE02 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'end_point',
rVALUE00 => PKG_XMAKE.VALUE(iCURSOR => XDOC,
sVALUE => SEND_POINT)));
end loop;
/* Формируем тело запроса */
BXML := PKG_XMAKE.SERIALIZE_TO_BLOB(iCURSOR => XDOC,
iTYPE => PKG_XMAKE.DOCUMENT_,
rNODE => PKG_XMAKE.CONCAT(iCURSOR => XDOC,
rNODE00 => PKG_XMAKE.ELEMENT(iCURSOR => XDOC,
sNAME => 'root',
rNODE00 => xNODE)),
rHEADER => PKG_XHEADER.WRAP_ALL(PKG_XHEADER.VERSION_1_0_,
PKG_XHEADER.ENCODING_UTF_,
PKG_XHEADER.STANDALONE_NONE_));
PKG_XMAKE.CLOSE_CURSOR(iCURSOR => XDOC);
end REQUIREMENTS_MAKE;
end UDO_PKG_EQUIPDS_SEND;
/

25
db/UDO_P_EQUIPDSCM_DATASET_MAKE.prc Normal file
View File

@ -0,0 +1,25 @@
create or replace procedure UDO_P_EQUIPDSCM_DATASET_MAKE
(
NCOMPANY in number, -- регистрационный номер организации
NEQUIPDSCM in number, -- Рег. номер класса оборудования выборки данных
DBEG in date, -- Дата С
DEND in date, -- Дата По
NLENGTH_GB in number, -- Ограничение размера файла в Гб
NDATASET_IDENT out number, -- Идентификатор буфера данных
NDATASET_CONFIG_IDENT out number -- Идентификатор буфера описания данных )
)
is
begin
/* Получение данных датасета и Описание структуры выборки */
UDO_PKG_EQUIPDS_DATAPROCESS.DATASET_CONF_SET(NCOMPANY => NCOMPANY,
NEQUIPDSCM => NEQUIPDSCM,
DBEG => DBEG,
DEND => DEND,
NLENGTH_GB => NLENGTH_GB,
NDATASET_IDENT => NDATASET_IDENT,
NDATASET_CONFIG_IDENT => NDATASET_CONFIG_IDENT
);
end UDO_P_EQUIPDSCM_DATASET_MAKE;
-- grant execute on UDO_P_EQUIPDSCM_DATASET_MAKE to public;
/

1
db/grants.sql
View File

@ -1,3 +1,4 @@
grant execute on UDO_PKG_EQUIPTCF to public;
grant execute on UDO_PKG_EQUIPDS to public;
grant execute on UDO_P_EQCONFIG_DATASET_MAKE to public;
grant execute on UDO_P_EQUIPDSCM_DATASET_MAKE to public;

121
service/modules/EQUIPDS.js Normal file
View File

@ -0,0 +1,121 @@
/*
Сервис интеграции ПП Парус 8 с WEB API
Дополнительный модуль: Интеграция с Фреймворка оценки и прогнозирования состояния оборудования
*/
//------------------------------
// Подключение внешних библиотек
//------------------------------
const xml2js = require("xml2js"); //Конвертация XML в JSON и JSON в XML
const _ = require("lodash"); //Работа с коллекциями и объектами
//---------------------
// Глобальные константы
//---------------------
// Список тегов которые должны содержать массив
const tag = [
"ftp_filepath",
"data_config"
];
//------------
// Тело модуля
//------------
//Обернуть содержимое тега в массив
const toArray = (obj, tags) => {
for (const prop in obj) {
const value = obj[prop];
if (tags.indexOf(prop) != -1 && !_.isArray(obj[prop])) {
obj[prop] = JSON.parse("[" + JSON.stringify(value) + "]");
}
if (typeof value === "object") {
toArray(value, tag);
}
}
return obj;
};
//Конвертация в XML
const toXML = obj => {
const builder = new xml2js.Builder();
return builder.buildObject(obj);
};
//Конвертация в JSON
const parseXML = xmlDoc => {
return new Promise((resolve, reject) => {
xml2js.parseString(xmlDoc, { explicitArray: false, mergeAttrs: true }, (err, result) => {
if (err) reject(err);
else resolve(result);
});
});
};
//Конвертация в JSON
const toJSON = async obj => {
let result = await parseXML(obj);
result = result.root;
toArray(result, tag);
return result;
};
//Обработчик "До" отправки запроса к сервису "СБИС"
const beforeDocParse = async prms => {
try {
//Конвертируем XML из "Парус 8" в понятный "СБИСу" JSON
let obj = await toJSON(prms.queue.blMsg.toString());
//Собираем и отдаём общий результат работы
return {
options: {
simple: false,
},
blMsg: Buffer.from(JSON.stringify(obj))
};
} catch (e) {
throw Error(e);
}
};
//Обработчик "После" запроса к сервису "СБИС"
const afterDocParseResp = async prms => {
//Преобразуем JSON ответ сервиса "СБИС" в XML, понятный "Парус 8"
let resu = null;
if (prms.queue.blResp) {
try {
resu = toXML(JSON.parse(prms.queue.blResp.toString()));
} catch (e) {
throw new Error(`Неожиданный ответ сервера. Ошибка интерпретации: ${e.message}`);
}
} else {
throw new Error('Сервер не вернул ответ');
}
//Возврат результата
return {
blResp: Buffer.from(resu)
};
};
//Обработчик "После" запроса к сервису
const beforeDocParseMsg = async prms => {
//Преобразуем JSON ответ сервиса в XML, понятный "Парус 8"
let resu = null;
if (prms.queue.blMsg) {
try {
resu = toXML(JSON.parse(prms.queue.blMsg.toString()));
} catch (e) {
throw new Error(`Неожиданный ответ сервера. Ошибка интерпретации: ${e.message}`);
}
} else {
throw new Error('Сервер не вернул ответ');
}
//Возврат результата
return {
blMsg: Buffer.from(resu)
};
};
exports.beforeDocParse = beforeDocParse;
exports.afterDocParseResp = afterDocParseResp;
exports.beforeDocParseMsg = beforeDocParseMsg;

155
service/modules/loadSCP_v2.js Normal file
View File

@ -0,0 +1,155 @@
/*
Сервис интеграции ПП Парус 8 с WEB API
Дополнительный модуль: Загрузки файла на сервер SCP
*/
//------------------------------
// Подключение внешних библиотек
//------------------------------
const { ServerError } = require("./../core/server_errors"); //Типовая ошибка
const { SERR_APP_SERVER_BEFORE, SERR_DB_SERVER } = require("./../core/constants"); //Общесистемные константы
const oracledb = require("oracledb"); //Работа с СУБД Oracle
const { Client } = require('node-scp')
//------------
// Тело модуля
//------------
//------------
// Чтение файла и запись в file_buffer
//------------
let myReadFiles = async(nRN,dbConn) => {
if (dbConn){
//Если есть подключение к БД
if (dbConn.bConnected) {
let pooledConnection;
try {
//Выполняем процедуру
console.log('!1 -',nRN);
pooledConnection = await dbConn.connection.getConnection();
console.log('!2 -',nRN);
let res = await pooledConnection.execute(
"select t.file_name, t.dataset from UDO_V_T_EQUIPDSCMFL1 t where t.prn = :nRN",
{nRN: nRN}
);
console.log('!!3 -',nRN);
return res.rows;
} catch (e) {
throw new ServerError(`Выполнение процедуры не удачно`, e.message);
} finally {
if (pooledConnection) {
try {
await pooledConnection.close();
} catch (e) {
throw new Error(`Чегото не то!`, e.message);
}
}
}
} else {
throw new ServerError(SERR_DB_SERVER, `Нет подключения к БД`);
}
} else{
throw new ServerError(SERR_DB_SERVER, `Что тот не то ${dbConn}`);
}
};
//------------
// Загрузка файлов на сервер SCP
//------------
async function uploadSCP(sHost, sPort, sUsername, sPassword, sSCPPatch, data ) {
try {
//console.log(`sHost ${sHost}, sPort ${sPort}, sUsername ${sUsername}, sPassword ${sPassword}, sSCPPatch ${sSCPPatch}`);
console.log("sHost",sHost);
console.log("sPort",sPort);
console.log("sUsername",sUsername);
console.log("sPassword",sPassword);
console.log("data",data);
const client = await Client({
host: sHost,
port: sPort,
username: sUsername,
password: sPassword,
// privateKey: fs.readFileSync('./key.pem'),
// passphrase: 'your key passphrase',
})
console.log("1",client);
await client.writeFile(sSCPPatch,
data,
)
//client.uploadFile(
// sLocalPatch,
// sSCPPatch,
// options?: TransferOptions
// )
//const result = await client.stat('/home/bilaboutsource/parus')
//console.log(result)
const result = await client.list('/home/sftp_user/parus')
console.log(result)
// you can perform upload multiple times
//await client.uploadFile('./test1.txt', '/workspace/test1.txt')
client.close() // remember to close connection after you finish
} catch (e) {
//console.log(`Ошибка загрузки файла ${e}`)
return e.message;
}
}
//Обработчик "До" для полученного сообщения
const uploadFileSCP = async prms => {
//Проверим, что есть подключение к БД
if (prms.dbConn.bConnected) {
try {
//Разбираем
//console.log("sHost:", prms.options["SHOST_SCP"]);
//console.log( "sPort:", prms.options["SPORT_SCP"]);
//console.log( "sUsername:", prms.options["SUSER_SCP"]);
//console.log( "sPassword:", prms.options["SPASS_SCP"]);
//console.log( "sLocalPatch:", prms.options["SPATCH_LOCAL"]);
//console.log( "sSCPPatch:", prms.options["SPATCH_FSERV"]);
//console.log("data",prms.queue.blMsg);
//let rows = await myReadFiles(prms.options["NEQUIPDSCMN"],prms.dbConn);
//console.log(rows.length);
//res = "urq";
//for ( let i= 0; i < rows.count; i++){
// console.log()
//}
//console.log(prms.options["SPATCH_FSERV"]);
//console.log(prms.queue.blMsg);
let res = await uploadSCP(prms.options["SHOST_SCP"],prms.options["SPORT_SCP"], prms.options["SUSER_SCP"], prms.options["SPASS_SCP"],prms.options["SPATCH_FSERV"], prms.queue.blMsg )
if (res){
stateres = 500;
}else{
stateres = 200;
res = "";
}
console.log(stateres);
console.log(res);
// Соберем результат в XML
let resXml = "";
resXml += "<root>";
resXml += `<state>${stateres}</state>`;
resXml += `<message>${res}</message>`;
resXml += "</root>";
return{
blMsg: Buffer.from(resXml),
bStopPropagation: true
}
} catch (e) {
throw new ServerError(SERR_APP_SERVER_BEFORE, `Ошибка обработки тела входящего сообщения: ${e.message}`);
}
} else throw new ServerError(SERR_DB_SERVER, "Нет подключения к БД");
};
//-----------------
// Интерфейс модуля
//-----------------
exports.uploadFileSCP = uploadFileSCP;