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 P_FORECAST_DATA
  (
    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       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 := 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(NRN => RCMML.RN, NPRECISION => ROUND(NPRECISION,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 P_FORECAST_DATA
  (
    NIDENT                  in number,                           -- Идентификатор процесса
    NEXSQUEUE               in number                            -- Регистрационный номер обрабатываемой позиции очереди обмена  
  )
  is
    REXSQUEUE               EXSQUEUE%rowtype;                    -- Запись позиции очереди
    NDATASET_IDENT          PKG_STD.TREF;                        -- Идентификатор данных выборки для прогноза
    BRESP                   blob;                                -- Буфер для результата
    SARG_DATASET_IDENT      PKG_STD.TSTRING := 'NDATASET_IDENT'; -- Наименование аргумента запроса для идентификатора данных выборки для прогноза
  begin
    /* Считываем позицию очереди */
    REXSQUEUE := GET_EXSQUEUE_ID(NFLAG_SMART => 0, NRN => NEXSQUEUE);
    /* Читаем параметры запроса - идентификатор файлового буфера с данными для прогноза */
    begin
      NDATASET_IDENT := TO_NUMBER(PKG_EXS.OPTIONS_READ(SOPTIONS => REXSQUEUE.OPTIONS,
                                                       SPATH    => PKG_EXS.SMSG_OPTION_CODE_QS || '/' ||
                                                                   SARG_DATASET_IDENT));
    exception
      when others then
        P_EXCEPTION(0, 'Неверный формат числа (%s).', SARG_DATASET_IDENT);
    end;
    if (NDATASET_IDENT is null) then
      P_EXCEPTION(0,
                  'Неуказан обязательный парметр запроса - %s.',
                  SARG_DATASET_IDENT);
    end if;
    /* Читаем данные из файлового буфера */
    for C in (select T.BDATA from FILE_BUFFER T where T.IDENT = NDATASET_IDENT)
    loop
      if (BRESP is not null) then
        P_EXCEPTION(0, 'Найдено более одного набора сведений о наработках.');
      end if;
      BRESP := C.BDATA;
    end loop;
    if (BRESP is null) then
      P_EXCEPTION(0, 'Сведений о наработках не найдено.');
    end if;
    /* Возвращаем ответ */
    PKG_EXS.PRC_RESP_RESULT_SET(NIDENT => NIDENT, SRESULT => PKG_EXS.SPRC_RESP_RESULT_OK, BRESP => BRESP);
  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_FORECAST_DATA;

  /* Инициализация настроек расширения для интеграции с фреймворк по прогнозированию ресурса оборудования */
  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,
                             NTIMEOUT_CONN   => null,
                             NTIMEOUT_ASYNCH => null,
                             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,
                             NTIMEOUT_CONN   => null,
                             NTIMEOUT_ASYNCH => null,
                             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,
                             NTIMEOUT_CONN   => null,
                             NTIMEOUT_ASYNCH => null,
                             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,
                             NTIMEOUT_CONN   => null,
                             NTIMEOUT_ASYNCH => null,
                             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,
                             NTIMEOUT_CONN   => null,
                             NTIMEOUT_ASYNCH => null,
                             NFORCE_UPDATE   => NFORCE_UPDATE,
                             NRN             => NEXSSERVICEFN);

  end INIT_EQUIPDS;
  
    
end UDO_PKG_EQUIPDS_EXS;
/
