CREATE OR REPLACE package body sc_cp_bis_ord_rateplan_pack_pg
  --
  ---@ SCC_CP
  ----- Тело пакета серверной части Corporate Portal
  ------ 020.08
  --
  -- SC_CP_BIS
  --
  -- Copyright (c) CJSC PETER-SERVICE, 2017.
  --
  -- Мочалов Дмитрий Эдуардович
  --
  -- Серверная логика взаимодействия с PETER-SERVICE BIS (Обработка заказа: Тарифный план и пакет опций)
  --
  -- Версия Дата       Автор               Изменение
  -- ------ ---------- ------------------- -------------------------------------------------------------------------------
  -- 020.08 21.08.2017 Мочалов Д.Э.        [SUBS-212089] Добавлена процедура connect_pack_to_rtpl
  -- 020.06 16.03.2017 Lev.Khruschev       BTS-152550 фикс формирования статусов заказа
  --
  -- 020.05 28.02.2017 Мочалов Д.Э.        Создание пакета
  --
IS

  CURRENT_VERSION_PB constant varchar2(32) := '020.08';


  ------------------------------------------------------------------------------------------------------------------------
  -- КОНСТАНТЫ И ТИПЫ ДАННЫХ
  ------------------------------------------------------------------------------------------------------------------------

  --
  -- Параметры обработчиков
  --
  subtype t_cphp_id IS cp_ord_hndl_params.cphp_id%TYPE;
  --
  -- Изменение ТП: подтверждение
  GC_PRMT_C_CLNT_IDS       constant t_cphp_id := GC_FULL_APPL_ID + 241; -- Список идентификаторов клиентов
  GC_PRMT_C_SUBS_IDS       constant t_cphp_id := GC_FULL_APPL_ID + 242; -- Список идентификаторов абонентов
  GC_PRMT_C_RTPL_ID        constant t_cphp_id := GC_FULL_APPL_ID + 243; -- Идентификатор ТП
  GC_PRMT_C_PACK_IDS       constant t_cphp_id := GC_FULL_APPL_ID + 244; -- Идентификаторы пакетов
  GC_PRMT_C_PACK_TYPE      constant t_cphp_id := GC_FULL_APPL_ID + 245; -- Тип пакета (периодический или разовый)
  GC_PRMT_C_DATE_FROM      constant t_cphp_id := GC_FULL_APPL_ID + 246; -- Дата смены ТП
  GC_PRMT_C_DATE_FROM_LIST constant t_cphp_id := GC_FULL_APPL_ID + 247; -- Список дат смены ТП по абонентам
  --
  -- Изменение ТП: выполнение
  GC_PRMT_A_CLNT_IDS       constant t_cphp_id := GC_FULL_APPL_ID + 248; -- Список идентификаторов клиентов
  GC_PRMT_A_SUBS_IDS       constant t_cphp_id := GC_FULL_APPL_ID + 249; -- Список идентификаторов абонентов
  GC_PRMT_A_RTPL_ID        constant t_cphp_id := GC_FULL_APPL_ID + 250; -- Идентификатор ТП
  GC_PRMT_A_PACK_IDS       constant t_cphp_id := GC_FULL_APPL_ID + 251; -- Идентификаторы пакетов
  GC_PRMT_A_PACK_TYPE      constant t_cphp_id := GC_FULL_APPL_ID + 252; -- Тип пакета (периодический или разовый)
  GC_PRMT_A_DATE_FROM      constant t_cphp_id := GC_FULL_APPL_ID + 253; -- Дата смены ТП
  GC_PRMT_A_DATE_FROM_LIST constant t_cphp_id := GC_FULL_APPL_ID + 254; -- Список дат смены ТП по абонентам


  -- Возвращает версию тела пакета.
  FUNCTION get_package_version
    RETURN varchar2 deterministic
  IS
    BEGIN
      RETURN CURRENT_VERSION_PB;
    END get_package_version;

  -- Регистрирует заказ на изменение ПАКЕТНОГО ТП вместе с опциями (с возможностью немедленного выполнения заказа на подтверждение в новом режиме).
  FUNCTION reg_rate_plan_pack_change(
    p_cpoh_id              IN cp_order_handler.cpoh_id%TYPE,
    p_cpcl_id              IN cp_clients.cpcl_id%TYPE,
    p_navi_user            IN varchar2,
    p_cpor_id              IN cp_orders.cpor_id%TYPE              := NULL,
    p_clnt_list            IN sc_cp_common_pg.array_number        := sc_cp_common_pg.empty_array_number,
    p_subs_list            IN sc_cp_common_pg.array_number,
    p_rtpl_id              IN rate_plans.rtpl_id%TYPE             := NULL,
    p_pack_list            IN sc_cp_common_pg.array_number        := sc_cp_common_pg.empty_array_number,
    p_in_date_from         IN varchar2                            := NULL,
    p_cp_zone_id           IN zones.zone_id%TYPE,
    p_processing_mode      IN cp_orders.processing_mode%TYPE      := NULL,
    p_notify_subs_by_sms   IN cp_orders.notify_subs_by_sms%TYPE   := NULL,
    p_notify_user_by_sms   IN cp_orders.notify_user_by_sms%TYPE   := NULL,
    p_notify_user_by_email IN cp_orders.notify_user_by_email%TYPE := NULL,
    p_susr_id              IN sc_users.susr_id%TYPE               := NULL
  )
    RETURN cp_orders.cpor_id%TYPE
  IS
    -- признак нового режима обработки заказ а
    C_IS_NEW_MODE       constant BOOLEAN := p_processing_mode IS NOT NULL;

    -- общие
    v_clnt_list         sc_cp_common_pg.array_number;
    v_subs_list         sc_cp_common_pg.array_number;
    v_subs_rownums      cp_tb_number;

    -- дополнительные
    v_rtpl_id           rate_plans.rtpl_id%TYPE;
    v_pack_list         sc_cp_common_pg.array_number;
    v_pack_type         NUMBER;
    v_in_date_from      DATE;
    v_in_date_from_list sc_cp_common_pg.array_date;

    -- количество всех абонентов в заказе на "подтверждение"
    v_subs_all_count    pls_integer;

    -- идентификатор созданного заказа
    v_cpor_id           cp_orders.cpor_id%TYPE;
    BEGIN
      -- ===================================================================================================================
      -- проверяем/подготавливаем необходимые параметры
      -- ===================================================================================================================

      -- инициализируем переменные значениями параметров
      v_clnt_list := p_clnt_list;
      v_subs_list := p_subs_list;
      v_rtpl_id   := p_rtpl_id;
      -- опции
      v_pack_list := p_pack_list;

      -- проверяем/получаем параметры
      IF
      p_cpoh_id = GC_HANDL_CONFIRM
      OR ( -- "выполнение" в новом режиме без предварительного "подтверждения"
        p_cpoh_id = GC_HANDL_ACTION
        AND p_cpor_id IS NULL
      )
      THEN
        -------------------------------
        -- используем входные параметры
        -------------------------------

        -- проверяем входные данные
        IF v_subs_list.COUNT = 0 THEN
          -- не заданы абоненты (error_code: 150080004)
          sc_cp_common_pg.raise_custom_error(
              error => sc_cp_common_pg.err_param_subs_list_empty
          );
        elsif v_rtpl_id IS NULL THEN
          -- не задан ТП (error_code: 150190003)
          sc_cp_common_pg.raise_custom_error(
              error => sc_cp_bis_common_pg.err_param_rtpl_empty
          );
        END IF;

        -- преобразуем дату согласно правилам: [CP:+P_CP_ZONE_ID], [CP:ACTION_SYSDATE], [CP:ACTION_FUTURE/PAST]
        sc_cp_bis_common_pg.mutation_date(
            p_date             => sc_cp_common_pg.to_truncated_date(p_in_date_from, 'dd'),
            p_zone_id          => p_cp_zone_id,
            p_subs_list        => v_subs_list,
            p_result_date      => v_in_date_from,
            p_result_date_list => v_in_date_from_list
        );
      elsif p_cpoh_id = GC_HANDL_ACTION THEN
        ------------------------------------------------
        -- получаем параметры от заказа на подтверждение
        ------------------------------------------------

        -- проверяем соответствие заказу на подтверждение
        sc_cp_orders_pg.check_action_order(
            p_cpoh_id         => p_cpoh_id,
            p_processing_mode => p_processing_mode,
            p_confirm_cpor_id => p_cpor_id,
            p_confirm_cpoh_id => GC_HANDL_CONFIRM
        );

        -- CLNT_ID
        sc_cp_orders_pg.get_param_array(
            p_cpor_id => p_cpor_id,
            p_cphp_id => GC_PRMT_C_CLNT_IDS,
            p_value   => v_clnt_list
        );

        -- SUBS_ID
        IF C_IS_NEW_MODE THEN
          -- для нового режима используем входной параметр
          v_subs_list := p_subs_list;
        ELSE
          -- для старого режима (список абонентов, по которым нет ошибок)
          v_subs_list := sc_cp_orders_pg.get_confirmed_subs_list(
              p_cpor_id => p_cpor_id,
              p_cphp_id => GC_PRMT_C_SUBS_IDS
          );
        END IF;
        -- получаем отсортированный упорядоченный список с номерами элементов
        sc_cp_orders_pg.get_sorted_param_array(
            p_cpor_id => p_cpor_id,
            p_cphp_id => GC_PRMT_C_SUBS_IDS,
            p_value   => v_subs_list,
            p_rownums => v_subs_rownums
        );
        IF v_subs_list.COUNT = 0 THEN
          -- не заданы абоненты (error_code: 150080004)
          sc_cp_common_pg.raise_custom_error(
              error => sc_cp_common_pg.err_param_subs_list_empty
          );
        END IF;

        -- обязательные параметры
        BEGIN

          -- RTPL_ID
          sc_cp_orders_pg.get_param_scalar(
              p_cpor_id => p_cpor_id,
              p_cphp_id => GC_PRMT_C_RTPL_ID,
              p_value   => v_rtpl_id
          );
          IF v_rtpl_id IS NULL THEN
            -- не задан ТП (error_code: 150190003)
            sc_cp_common_pg.raise_custom_error(
                error => sc_cp_bis_common_pg.err_param_rtpl_empty
            );
          END IF;

          -- DATE_FROM (дата в зоне BIS относительно зоны пользователя КП)
          sc_cp_orders_pg.get_param_scalar(
              p_cpor_id => p_cpor_id,
              p_cphp_id => GC_PRMT_C_DATE_FROM,
              p_value   => v_in_date_from
          );

          --обязательные параметры для пакетов (тарифных опций)
          IF v_pack_list.COUNT > 0 THEN
            -- PACK_ID
            sc_cp_orders_pg.get_param_array(
                p_cpor_id   => p_cpor_id,
                p_cphp_id   => GC_PRMT_C_PACK_IDS,
                p_value     => v_pack_list,
                p_mandatory => TRUE
            );

            -- PACK_TYPE
            sc_cp_orders_pg.get_param_scalar(
                p_cpor_id  => p_cpor_id,
                p_cphp_id  => GC_PRMT_C_PACK_TYPE,
                p_value    => v_pack_type,
                p_optional => C_IS_NEW_MODE -- для нового режима параметр необязательный
            );

            -- DATE_FROM (даты в зоне BIS относительно зон абонентов)
            sc_cp_orders_pg.get_param_array(
                p_cpor_id   => p_cpor_id,
                p_cphp_id   => GC_PRMT_C_DATE_FROM_LIST,
                p_value     => v_in_date_from_list,
                p_rownums   => v_subs_rownums, -- поэлементная согласованность со списком абонентов
                p_mandatory => C_IS_NEW_MODE -- для нового режима параметр обязательный
            );
          END IF;


        exception
          WHEN NO_DATA_FOUND THEN
          -- параметр не найден (error_code: 150080001)
          sc_cp_common_pg.raise_custom_error(
              error => sc_cp_common_pg.err_param_not_found
          );
        END;

        -- меняем статус заказа с типом "подтверждение", на основе которого регистрируется "выполнение"
        --
        -- определяем сколько было всего абонентов в заказе для выставления нужного статуса
        sc_cp_orders_pg.get_count_subs_order(
            p_cpor_id => p_cpor_id,
            p_cphp_id => GC_PRMT_C_SUBS_IDS,
            p_value   => v_subs_all_count
        );
        -- выставлем нужный статус
        sc_cp_orders_pg.change_order_state(
            p_cpor_id    => p_cpor_id,
            p_cpos_id    => CASE WHEN v_subs_list.COUNT = v_subs_all_count
              THEN sc_cp_orders_pg.c_os_confirmed           -- по всем абонентам
                            ELSE sc_cp_orders_pg.c_os_confirmed_partially -- по части абонентов
                            END,
            p_exec_date  => sysdate,
            p_progress   => 1,
            p_autonom_tr => FALSE
        );
      ELSE
        ----------------------------------------------------------
        -- неверный тип обработчика заказа (error_code: 150080007)
        ----------------------------------------------------------
        sc_cp_common_pg.raise_custom_error(
            error => sc_cp_common_pg.err_order_handl_not_found
        );
      END IF;

      -- =================================================================================================================
      -- регистрируем заказ
      -- =================================================================================================================

      -- проверяем возможность регистрации заказа
      IF
      sc_cp_orders_pg.check_orders(
          p_cpoh_id    => GC_HANDL_CONFIRM,
          p_cpcl_id    => p_cpcl_id,
          p_param_name => sc_cp_orders_pg.c_param_sub_list_name,
          p_subs_list  => v_subs_list
      )
      AND sc_cp_orders_pg.check_orders(
          p_cpoh_id    => GC_HANDL_ACTION,
          p_cpcl_id    => p_cpcl_id,
          p_param_name => sc_cp_orders_pg.c_param_sub_list_name,
          p_subs_list  => v_subs_list
      )
      THEN
        ----------------
        -- создаем заказ
        ----------------
        v_cpor_id := sc_cp_orders_pg.create_orders(
            p_cpoh_id              => p_cpoh_id,
            p_cpcl_id              => p_cpcl_id,
            p_parent_id            => CASE p_cpoh_id WHEN GC_HANDL_ACTION THEN p_cpor_id END,
            p_navi_user            => p_navi_user,
            p_processing_mode      => CASE WHEN p_cpoh_id = GC_HANDL_CONFIRM AND C_IS_NEW_MODE
              THEN sc_cp_orders_pg.GC_PM_PARTIAL
                                      ELSE p_processing_mode
                                      END,
            p_notify_subs_by_sms   => CASE WHEN p_cpoh_id = GC_HANDL_ACTION THEN p_notify_subs_by_sms END,
            p_notify_user_by_sms   => CASE WHEN p_cpoh_id = GC_HANDL_ACTION THEN p_notify_user_by_sms END,
            p_notify_user_by_email => CASE WHEN p_cpoh_id = GC_HANDL_ACTION THEN p_notify_user_by_email END,
            p_susr_id              => p_susr_id
        );

        ----------------------
        -- заполняем параметры
        ----------------------

        -- CLNT_ID
        sc_cp_orders_pg.create_param_array(
            p_cphp_id => CASE WHEN p_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_CLNT_IDS
                         ELSE GC_PRMT_A_CLNT_IDS
                         END,
            p_cpor_id => v_cpor_id,
            p_array   => v_clnt_list
        );

        -- SUBS_ID
        sc_cp_orders_pg.create_param_array(
            p_cphp_id => CASE WHEN p_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_SUBS_IDS
                         ELSE GC_PRMT_A_SUBS_IDS
                         END,
            p_cpor_id => v_cpor_id,
            p_array   => v_subs_list
        );

        -- RTPL_ID
        sc_cp_orders_pg.create_param_scalar(
            p_cphp_id => CASE WHEN p_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_RTPL_ID
                         ELSE GC_PRMT_A_RTPL_ID
                         END,
            p_cpor_id => v_cpor_id,
            p_value   => v_rtpl_id
        );

        -- PACK_ID
        sc_cp_orders_pg.create_param_array(
            p_cphp_id => CASE WHEN p_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_PACK_IDS
                         ELSE GC_PRMT_A_PACK_IDS
                         END,
            p_cpor_id => v_cpor_id,
            p_array   => v_pack_list
        );

        -- DATE_FROM (дата в зоне BIS относительно зоны пользователя КП)
        sc_cp_orders_pg.create_param_scalar(
            p_cphp_id => CASE WHEN p_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_DATE_FROM
                         ELSE GC_PRMT_A_DATE_FROM
                         END,
            p_cpor_id => v_cpor_id,
            p_value   => v_in_date_from
        );

        -- DATE_FROM (даты в зоне BIS относительно зон абонентов)
        sc_cp_orders_pg.create_param_array(
            p_cphp_id => CASE WHEN p_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_DATE_FROM_LIST
                         ELSE GC_PRMT_A_DATE_FROM_LIST
                         END,
            p_cpor_id => v_cpor_id,
            p_array   => v_in_date_from_list
        );

        --------------------------------------------------------------------
        -- немедленно выполняем заказ с типом "подтверждение" в новом режиме
        --------------------------------------------------------------------
        IF p_cpoh_id = GC_HANDL_CONFIRM THEN
          -- фиксируем транзакцию
          commit;

          -- выполняем заказ
          sc_cp_orders_pg.execute_order_handler(
              p_cpor_id => v_cpor_id
          );
        END IF;

        ----------------------------------
        -- возвращаем идентификатор заказа
        ----------------------------------
        RETURN v_cpor_id;
      END IF;
    END reg_rate_plan_pack_change;

  -- Обрабатывает заказ на изменение ПАКЕТНОГО ТП.
  FUNCTION handl_rp_and_packs_client_bis(
    p_cpor_id   IN            cp_orders.cpor_id%TYPE,
    p_navi_user IN            varchar2,
    p_locator   IN OUT nocopy cp_order_data.xml_data%TYPE
  )
    RETURN NUMBER
  IS
    -- общие
    v_order                 cp_orders%rowtype;
    v_is_new_mode           BOOLEAN;
    v_sum_charges_rateplan  sc_cp_bis_common_pg.gt_sum_charge_list;
    v_sum_charges_packs     sc_cp_bis_common_pg.gt_sum_charge_list;
    v_master_sacs_id        sc_access_levels.sacs_id%TYPE;

    -- служебные
    v_result                NUMBER;
    v_order_result          t_sc_cp_order_result_rec;
    v_critical_err          sc_cp_common_pg.array_number;
    v_xml_doc               cp_order_data.xml_data%TYPE;
    C_SAVEPOINT             constant varchar2(30) := $$plsql_unit;
    v_curr_subs_or_status   varchar2(9);
    v_ok_subs_count         pls_integer;
    v_partial_subs_count    pls_integer;
    v_subs_rownums          cp_tb_number;
    v_common_number_list    sc_cp_common_pg.array_number;
    v_idx                   binary_integer;
    v_idx_2                 binary_integer;
    v_xml_detail            CLOB;

    -- дополнительные
    v_subs_list             sc_cp_common_pg.array_number;
    v_rtpl_id               rate_plans.rtpl_id%TYPE;
    v_rtpl_already_on       BOOLEAN;
    v_in_date_from          DATE;
    v_in_date_from_list     sc_cp_common_pg.array_date;
    v_tariff_options_source sc_kernel.gt_tariff_options_to_order_rec;

    -- специальные абонентские
    v_clnt_id               clients.clnt_id%TYPE;
    v_msisdn                number_sets.msisdn%TYPE;
    v_dummy_date_from       DATE;
    v_charge_total          NUMBER; --итоговая
    v_charge_rateplan       NUMBER; --для ТП
    v_charge_rateplan_tf    NUMBER;
    v_tariff_options_result sc_kernel.gt_tariff_options_of_order_rec;


    PROCEDURE fill_nested_table(
      p_tn    OUT cp_tb_number,
      p_array IN  sc_kernel.ids_array
    )
    IS
      i binary_integer;
      j binary_integer;
    BEGIN
      p_tn := cp_tb_number();
      p_tn.extend(p_array.COUNT);
      -- преобразуем ассоциативный массив во вложенную таблицу
      i := p_array.FIRST;
      j := p_tn.FIRST;
      while i IS NOT NULL loop
        p_tn(j) := p_array(i);
        i := p_array.NEXT(i);
        j := p_tn.NEXT(j);
      END loop;
    END fill_nested_table;


    FUNCTION check_mandatory_option_error(
      p_rtpl_id               rate_plans.rtpl_id%TYPE,
      p_tariff_options_result sc_kernel.gt_tariff_options_of_order_rec
    )
      RETURN BOOLEAN
    IS

      v_packs_appended    sc_kernel.ids_array;               -- список идентификаторов уже подключенных (до заказа) пакетов ?
      v_packs_to_append   sc_kernel.gt_sbs_pack_order_list;  -- список подключаемых пакетов с зависимостями
      -- sbs_packs_to_append
      v_pack_order_rec    sc_kernel.gt_sbs_pack_order_rec;

      v_tn_packs          cp_tb_number;
      i                   binary_integer;
      j                   binary_integer;
      res                 NUMBER;

      BEGIN

        v_packs_appended := p_tariff_options_result.sbs_packs_already_appended;
        v_packs_to_append := p_tariff_options_result.sbs_packs_to_append;

        -- копируем опции to_append в v_packs_appended
        j := v_packs_appended.COUNT;
        i := v_packs_to_append.FIRST;
        while i IS NOT NULL loop
          v_pack_order_rec := v_packs_to_append(i);
          v_packs_appended(j) := v_pack_order_rec.source_id;
          j := v_packs_appended(j);
          i := v_packs_to_append.NEXT(i);
        END loop;

        -- преобразуем ассоциативный массив во вложенную таблицу
        fill_nested_table(
          p_tn => v_tn_packs,
          p_array => v_packs_appended);

        -- проверка обязательных опций
        SELECT COUNT(*)
          INTO res
          FROM (SELECT sbog.sbog_id, COUNT(tp.column_value)
                  FROM sc_business_objects sbo
                  INNER JOIN sc_business_obj_to_groups sbotg ON sbo.sbo_id = sbotg.sbo_sbo_id
                  INNER JOIN sc_business_object_groups sbog  ON sbotg.sbog_sbog_id=sbog.sbog_id
                  INNER JOIN packs p ON p.pack_id=sbo.obj_id1 AND sbo.sbot_sbot_id=2
                  LEFT JOIN TABLE(v_tn_packs) tp ON tp.column_value = p.pack_id
                 WHERE p.rtpl_rtpl_id=p_rtpl_id AND sbog.mandatory_yn='Y'
                 GROUP BY sbog.sbog_id
                 HAVING COUNT(tp.column_value) = 0) a;
        IF res <> 0 THEN
          RETURN TRUE;
        END IF;

        -- проверка "исключающих" опций
        SELECT COUNT(*)
          INTO res
          FROM (SELECT sbog.sbog_id, COUNT(tp.column_value)
                  FROM sc_business_objects sbo
                  INNER JOIN sc_business_obj_to_groups sbotg ON sbo.sbo_id = sbotg.sbo_sbo_id
                  INNER JOIN sc_business_object_groups sbog  ON sbotg.sbog_sbog_id=sbog.sbog_id
                  INNER JOIN packs p ON p.pack_id=sbo.obj_id1 AND sbo.sbot_sbot_id=2
                  LEFT JOIN TABLE(v_tn_packs) tp ON tp.column_value = p.pack_id
                 WHERE p.rtpl_rtpl_id=p_rtpl_id AND sbog.exclusive_yn='Y'
                 GROUP BY sbog.sbog_id
                 HAVING COUNT(tp.column_value) > 1) b;

        IF res <> 0 THEN
          RETURN TRUE;
        END IF;

        RETURN FALSE;
      END check_mandatory_option_error;

    -- Получает список заказов в виде XML структуры.
    FUNCTION get_order_list_as_xml(
      p_root_tag          IN varchar2,
      p_row_tag           IN varchar2                         := 'ITEM',
      p_date_tag          IN varchar2                         := 'DATE',
      p_dep_app_tag       IN varchar2                         := 'DEP_APP',
      p_dep_app_serv_tag  IN varchar2                         := 'SERVS_DEP_APP',
      p_dep_del_tag       IN varchar2                         := 'DEP_DEL',
      p_dep_del_serv_tag  IN varchar2                         := 'SERVS_DEP_DEL',
      p_obj_tag           IN varchar2                         := 'ID',
      p_chrg_tag          IN varchar2                         := 'CHRG',
      p_included_tag      IN varchar2                         := 'INCLUDED_IN_DEP',
      p_order_list        IN sc_kernel.gt_sbs_pack_order_list
    )
      RETURN CLOB
    IS
      v_idx binary_integer;
      v_xml CLOB;
      BEGIN
        v_idx := p_order_list.FIRST;
        while v_idx IS NOT NULL loop
          v_xml := v_xml || sc_cp_orders_pg.get_obj_as_xml(
              p_tag => p_row_tag,
              p_obj =>
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_obj_tag,
                  p_obj => p_order_list(v_idx).source_id
              ) ||
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_date_tag,
                  p_obj => p_order_list(v_idx).opr_date
              ) ||
              sc_cp_orders_pg.get_obj_list_as_xml(
                  p_root_tag => p_dep_app_tag,
                  p_obj_tag  => p_obj_tag,
                  p_obj_list => p_order_list(v_idx).packs_dep_append
              ) ||
              sc_cp_orders_pg.get_obj_list_as_xml(
                  p_root_tag => p_dep_app_serv_tag,
                  p_obj_tag  => p_obj_tag,
                  p_obj_list => p_order_list(v_idx).servs_dep_append
              ) ||
              sc_cp_orders_pg.get_obj_list_as_xml(
                  p_root_tag => p_dep_del_tag,
                  p_obj_tag  => p_obj_tag,
                  p_obj_list => p_order_list(v_idx).packs_dep_delete
              ) ||
              sc_cp_orders_pg.get_obj_list_as_xml(
                  p_root_tag => p_dep_del_serv_tag,
                  p_obj_tag  => p_obj_tag,
                  p_obj_list => p_order_list(v_idx).servs_dep_delete
              ) ||
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_chrg_tag,
                  p_obj => p_order_list(v_idx).charge
              ) ||
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_included_tag,
                  p_obj => CASE WHEN p_order_list(v_idx).included_in_dep THEN 1 END
              )
          );
          v_idx := p_order_list.NEXT(v_idx);
        END loop;

        RETURN sc_cp_orders_pg.get_obj_as_xml(
            p_tag => p_root_tag,
            p_obj => v_xml
        );
      END get_order_list_as_xml;

    -- Получает список заказов в виде XML структуры.
    FUNCTION get_error_list_as_xml(
      p_root_tag        IN varchar2,
      p_row_tag         IN varchar2                         := 'ITEM',
      p_type_tag        IN varchar2                         := 'TYPE',
      p_src_id_tag      IN varchar2                         := 'SRC_ID',
      p_lnk_err_id_tag  IN varchar2                         := 'LNK_ERR_CODE',
      p_lnk_id_tag      IN varchar2                         := 'LNK_ID',
      p_lnk_serv_id_tag IN varchar2                         := 'LNK_SERV_ID',
      p_lnk_date_tag    IN varchar2                         := 'LNK_DATE',
      p_error_list      IN sc_kernel.gt_sbs_pack_error_list
    )
      RETURN CLOB
    IS
      v_idx binary_integer;
      v_xml CLOB;
      BEGIN
        v_idx := p_error_list.FIRST;
        while v_idx IS NOT NULL loop
          v_xml := v_xml || sc_cp_orders_pg.get_obj_as_xml(
              p_tag => p_row_tag,
              p_obj =>
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_type_tag,
                  p_obj => p_error_list(v_idx).error_type
              ) ||
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_src_id_tag,
                  p_obj => p_error_list(v_idx).source_id
              ) ||
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_lnk_err_id_tag,
                  p_obj => p_error_list(v_idx).linked_err_code
              ) ||
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_lnk_id_tag,
                  p_obj => p_error_list(v_idx).linked_pack_id
              ) ||
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_lnk_serv_id_tag,
                  p_obj => p_error_list(v_idx).linked_serv_id
              ) ||
              sc_cp_orders_pg.get_obj_as_xml(
                  p_tag => p_lnk_date_tag,
                  p_obj => p_error_list(v_idx).linked_date
              )
          );
          v_idx := p_error_list.NEXT(v_idx);
        END loop;

        RETURN sc_cp_orders_pg.get_obj_as_xml(
            p_tag => p_root_tag,
            p_obj => v_xml
        );
      END get_error_list_as_xml;

    BEGIN
      -- ===================================================================================================================
      -- получаем/формируем параметры заказа
      -- ===================================================================================================================

      --------
      -- общие
      --------
      --всегда новый режим
      v_is_new_mode := TRUE;

      -- все параметры
      sc_cp_orders_pg.get_order_common_params(
          p_cpor_id   => p_cpor_id,
          p_navi_user => p_navi_user,
          p_order     => v_order
      );

      -- проверяем тип обработчика
      IF v_order.cpoh_cpoh_id NOT IN (GC_HANDL_CONFIRM, GC_HANDL_ACTION) THEN
        -- неверный тип обработчика заказа (error_code: 150080007)
        sc_cp_orders_pg.write_fatal_error(
            p_cpor_id => p_cpor_id,
            p_err     => sc_cp_common_pg.err_order_handl_not_found,
            cl        => v_xml_doc
        );
        sc_cp_common_pg.raise_custom_error(
            error => sc_cp_common_pg.err_order_handl_not_found
        );
      END IF;

      -- УД владельца заказа (по типу ВКК)
      v_master_sacs_id := sc_cp_orders_pg.get_order_client_sacs_id(
          p_cpor_id => p_cpor_id
      );

      ------------
      -- служебные
      ------------

      -- инициализируем результат обработки заказа КП
      v_order_result := t_sc_cp_order_result_rec(
          version                => '3.0',
          subs_order_result_list => t_sc_cp_subs_order_result_list(),
          sum_charge             => CASE WHEN v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM THEN 0 END
      );

      -- заполняем массив критических (общих, независимых от конкретного абонента) ошибок при обработке абонента
      -- в новом режиме все ошибки некритические
      v_critical_err.DELETE;

      -- инициализируем количество обработанных абонентов без ошибок
      v_ok_subs_count := 0;
      v_partial_subs_count := 0;

      BEGIN
        -- PACK_ID
        sc_cp_orders_pg.get_param_array(
            p_cpor_id => p_cpor_id,
            p_cphp_id => CASE WHEN v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_PACK_IDS
                         ELSE GC_PRMT_A_PACK_IDS
                         END,
            p_value   => v_common_number_list
        );
        EXCEPTION WHEN NO_DATA_FOUND THEN
        v_common_number_list := sc_cp_common_pg.empty_array_number;
      END;

      -----------------
      -- дополнительные
      -----------------
      BEGIN
        -- SUBS_ID
        sc_cp_orders_pg.get_param_array(
            p_cpor_id   => p_cpor_id,
            p_cphp_id   => CASE WHEN v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_SUBS_IDS
                           ELSE GC_PRMT_A_SUBS_IDS
                           END,
            p_value     => v_subs_list,
            p_mandatory => TRUE
        );
        -- получаем упорядоченный список с номерами элементов
        sc_cp_orders_pg.get_sorted_param_array(
            p_cpor_id => p_cpor_id,
            p_cphp_id => CASE WHEN v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_SUBS_IDS
                         ELSE GC_PRMT_A_SUBS_IDS
                         END,
            p_value   => v_subs_list,
            p_rownums => v_subs_rownums
        );

        -- RTPL_ID
        sc_cp_orders_pg.get_param_scalar(
            p_cpor_id => p_cpor_id,
            p_cphp_id => CASE WHEN v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_RTPL_ID
                         ELSE GC_PRMT_A_RTPL_ID
                         END,
            p_value   => v_rtpl_id
        );
        IF v_rtpl_id IS NULL THEN
          -- не задан ТП (error_code: 150190003)
          sc_cp_orders_pg.write_fatal_error(
              p_cpor_id => p_cpor_id,
              p_err     => sc_cp_bis_common_pg.err_param_rtpl_empty,
              cl        => v_xml_doc
          );
          sc_cp_common_pg.raise_custom_error(
              error => sc_cp_bis_common_pg.err_param_rtpl_empty
          );
        END IF;

        ----------------------------------------------------------------------------------------------------
        -- PROCEDURE
        --Тип операции всегда на подключение тарифных опций
        v_tariff_options_source.sbs_opr_type := sc_cp_bis_ord_pack_pg.GC_OPR_TYPE_ON;

        -- записываем в соответствующий параметр результата обработки заказа КП
        v_order_result.opr_type := sc_cp_bis_ord_pack_pg.GC_OPR_TYPE_NAME_ON;

        -- данные по пакетам
        v_tariff_options_source.process_packages := TRUE;

        -- все пакеты, кроме контентных
        v_tariff_options_source.packs_return_type := -1;

        -- преобразовываем в массив базовой подсистемы
        IF v_common_number_list.COUNT > 0 THEN
          v_idx := v_common_number_list.FIRST;
          while v_idx IS NOT NULL loop
            v_tariff_options_source.pack_ids(v_idx) := v_common_number_list(v_idx);
            --
            v_idx := v_common_number_list.NEXT(v_idx);
          END loop;

          -- DATE_FROM (даты в зоне BIS относительно зон абонентов)
          sc_cp_orders_pg.get_param_array(
              p_cpor_id   => p_cpor_id,
              p_cphp_id   => CASE WHEN v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM
                THEN GC_PRMT_C_DATE_FROM_LIST
                             ELSE GC_PRMT_A_DATE_FROM_LIST
                             END,
              p_value     => v_in_date_from_list,
              p_rownums   => v_subs_rownums, -- поэлементная согласованность со списком абонентов
              p_mandatory => v_is_new_mode -- для нового режима параметр обязательный
          );

        END IF;


        ----------------------------------------------------------------------------------------------------

        -- DATE_FROM (дата в зоне BIS относительно зоны пользователя КП)
        sc_cp_orders_pg.get_param_scalar(
            p_cpor_id => p_cpor_id,
            p_cphp_id => CASE WHEN v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM
              THEN GC_PRMT_C_DATE_FROM
                         ELSE GC_PRMT_A_DATE_FROM
                         END,
            p_value   => v_in_date_from
        );
        --Дублирование в сущность тарифных опций
        v_tariff_options_source.sbs_date_from := v_in_date_from;

        -- признак выполнения только проверок (режим подтверждения)
        IF v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM THEN
          v_tariff_options_source.check_only := TRUE;
        END IF;

        -- для нового режима указываем пошаговую обработку элементов заказа
        v_tariff_options_source.process_step_by_step := TRUE;

        -- признак возможности частичного выполнения (после проверок) заказа
        IF v_order.cpoh_cpoh_id = GC_HANDL_ACTION THEN
          v_tariff_options_source.sbs_exec_partial := v_order.processing_mode = sc_cp_orders_pg.GC_PM_PARTIAL;
        END IF;

        exception
        WHEN NO_DATA_FOUND THEN
        -- параметр не найден (error_code: 150080001)
        sc_cp_orders_pg.write_fatal_error(
            p_cpor_id => p_cpor_id,
            p_err     => sc_cp_common_pg.err_param_not_found,
            cl        => v_xml_doc
        );
        sc_cp_common_pg.raise_custom_error(
            error => sc_cp_common_pg.err_param_not_found
        );
      END;


      -- ===================================================================================================================
      -- выполняем заказ
      -- ===================================================================================================================

      -- в цикле по каждому абоненту
      v_idx := v_subs_list.FIRST;
      while v_idx IS NOT NULL loop
        -- устанавливаем точку сохранения для обеспечения целостности изменений по абоненту
        v_curr_subs_or_status := sc_cp_orders_pg.set_curr_subs_or_status(
            p_or_status => sc_cp_orders_pg.GC_SUB_OR_OK,
            p_savepoint => C_SAVEPOINT
        );

        ------------------------------------------
        -- выполняем основные действия по абоненту
        ------------------------------------------
        BEGIN
          -----------------------------------------------
          -- определяем специальные абонентские параметры
          -----------------------------------------------

          -- клиент абонента
          v_clnt_id := sc_kernel.get_clnt_by_subs(
              p_subs_id => v_subs_list(v_idx)
          );

          -- MSISDN абонента
          v_msisdn  := sc_kernel.get_msisdn_by_subs_id(
              p_subs_id => v_subs_list(v_idx)
          );

          -- дата в зоне BIS относительно зоны абонента
          -- (эта дата может быть не определена, в этом случае берем дату относительно зоны пользователя КП)
          IF v_in_date_from_list.COUNT > 0 THEN
            v_in_date_from := v_in_date_from_list(v_idx);
          END IF;

          ----------------------------------------------------------------
          -- списки дат заказа в старом режиме
          IF
          -- новая дата
          v_in_date_from_list.COUNT > 0
          -- либо дата одна, но нужно заполнить в первый раз
          OR v_idx = v_subs_list.FIRST
          THEN
            v_idx_2 := v_tariff_options_source.pack_ids.FIRST;
            while v_idx_2 IS NOT NULL loop
              v_tariff_options_source.pack_dates(v_idx_2) := v_tariff_options_source.sbs_date_from;
              --
              v_idx_2 := v_tariff_options_source.pack_ids.NEXT(v_idx_2);
            END loop;
          END IF;
          ----------------------------------------------------------------

          ----------------------
          -- выполняем обработку
          ----------------------
          -- В случае, если у абонента еще не подключен запрашиваемый ТП
          v_rtpl_already_on := v_rtpl_id = sc_kernel.get_current_rate_plan( p_subs_id => v_subs_list(v_idx), p_date => v_in_date_from );
          IF NOT v_rtpl_already_on THEN

            -- выполняем пользовательские дополнительные проверки
            sc_cp_bis_user_func_pg.up_check_order_rateplan(
                p_clnt_id   => v_clnt_id,
                p_subs_id   => v_subs_list(v_idx),
                p_rtpl_id   => v_rtpl_id,
                p_date_from => v_in_date_from
            );
            -- вызываем базовую процедуру...
            IF v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM THEN
              -- подтверждения смены ТП
              sc_custom.i_change_rate_plan_confirm_1(
                  p_subs_id         => v_subs_list(v_idx),
                  rtpl_id           => v_rtpl_id,
                  subscriber_msisdn => v_msisdn,
                  in_date_from      => v_in_date_from,
                  date_from         => v_dummy_date_from,
                  charge            => v_charge_rateplan,
                  charge_tf         => v_charge_rateplan_tf,
                  p_bis_tz          => 1 -- даты передаются в зоне сервера BIS
              );
              -- проверяем достаточность средств на счету клиента для списания накопленной суммы
              sc_cp_bis_common_pg.check_balance_for_oper_list(
                  p_clnt_id     => v_clnt_id,
                  p_subs_id     => v_subs_list(v_idx),
                  p_sum_charges => v_sum_charges_rateplan,
                  p_charge      => v_charge_rateplan
              );
            ELSE
              -- выполнение смены ТП
              sc_custom.i_change_rate_plan_1(
                  p_clnt_id         => v_clnt_id,
                  p_subs_id         => v_subs_list(v_idx),
                  rtpl_id           => v_rtpl_id,
                  subscriber_msisdn => v_msisdn,
                  p_navi_user       => v_order.navi_user,
                  date_from         => v_in_date_from,
                  charge            => v_charge_rateplan,
                  charge_tf         => v_charge_rateplan_tf,
                  p_bis_tz          => 1 -- даты передаются в зоне сервера BIS
              );
            END IF;

          END IF;

          ----------Блок тарифных опций --------------------
          -- выполняем пользовательские дополнительные проверки
          -- (в цикле по каждому пакету)
          v_idx_2 := v_tariff_options_source.pack_ids.FIRST;
          while v_idx_2 IS NOT NULL loop
            sc_cp_bis_user_func_pg.up_check_order_pack(
                p_clnt_id   => v_clnt_id,
                p_subs_id   => v_subs_list(v_idx),
                p_pack_id   => v_tariff_options_source.pack_ids(v_idx_2),
                p_date_from => v_tariff_options_source.sbs_date_from,
                p_operation => v_tariff_options_source.sbs_opr_type
            );
            --
            v_idx_2 := v_tariff_options_source.pack_ids.NEXT(v_idx_2);
          END loop;

          -- вызываем базовую процедуру...
          -- подтверждения/изменения тарифных опций
          sc_custom.order_tariff_options(
              p_clnt_id         => v_clnt_id,
              p_subs_id         => v_subs_list(v_idx),
              p_rtpl_id         => v_rtpl_id,
              p_master_sacs_id  => v_master_sacs_id,
              p_in_tz           => 1,
              p_navi_user       => v_order.navi_user,
              p_sum_corp_charge => sc_cp_bis_common_pg.get_charge_for_oper_list(
                  p_clnt_id     => v_clnt_id,
                  p_sum_charges => v_sum_charges_packs
              ),
              --
              p_order_source    => v_tariff_options_source,
              --
              p_order_result    => v_tariff_options_result
          );

          --------------------------------------------------

          ----------------------------------------------------------------------------
          -- выполняем дополнительные проверки результата выполнения базовой процедуры
          ----------------------------------------------------------------------------
          /*
          -- Требования ФС_60772 не подразумевают данную проверку, но она будет введена позже.
          -- проверка соответствия отключаемых/подключаемых опций бизнес-логике
          if check_mandatory_option_error(
              p_rtpl_id => v_rtpl_id,
              p_tariff_options_result => v_tariff_options_result) then
            sc_cp_common_pg.raise_custom_error(
                error => sc_cp_common_pg.err_create_order
            );
          end if;
          */
          -- недоступность, коллизии, автоматическое дополнительное отключение/подключение
          -- записываем информацию по ТП
          v_xml_detail := sc_cp_orders_pg.get_obj_as_xml(
              p_tag => 'RATEPLAN',
              p_obj => (sc_cp_orders_pg.get_obj_as_xml(
                            p_tag => 'ID',
                            p_obj => v_rtpl_id
                        ) ||
                        sc_cp_orders_pg.get_obj_as_xml(
                            p_tag => 'STATUS',
                            p_obj => CASE WHEN v_rtpl_already_on THEN GC_RTPL_UNCHANGED ELSE v_curr_subs_or_status END
                        ) ||
                        sc_cp_orders_pg.get_obj_as_xml(
                            p_tag => 'CHARGE',
                            p_obj => nvl(v_charge_rateplan, 0)
                        ))
          );

          -- формируем детализацию результата в виде XML структуры
          v_xml_detail := v_xml_detail ||
                          -- уже подключенные и отключенные услуги
                          sc_cp_orders_pg.get_obj_list_as_xml(
                              p_root_tag => 'PACKS_ALREADY_APPENDED',
                              p_obj_list => v_tariff_options_result.sbs_packs_already_appended
                          ) ||
                          sc_cp_orders_pg.get_obj_list_as_xml(
                              p_root_tag => 'PACKS_ALREADY_DELETED',
                              p_obj_list => v_tariff_options_result.sbs_packs_already_deleted
                          ) ||
                          -- подключаемые и отключаемые услуги
                          get_order_list_as_xml(
                              p_root_tag   => 'PACKS_TO_APPEND',
                              p_order_list => v_tariff_options_result.sbs_packs_to_append
                          ) ||
                          get_order_list_as_xml(
                              p_root_tag   => 'PACKS_TO_DELETE',
                              p_order_list => v_tariff_options_result.sbs_packs_to_delete
                          ) ||
                          -- ошибки
                          get_error_list_as_xml(
                              p_root_tag   => 'PACKS_APPEND_ERROR',
                              p_error_list => v_tariff_options_result.sbs_pack_append_errors
                          ) ||
                          get_error_list_as_xml(
                              p_root_tag   => 'PACKS_DELETE_ERROR',
                              p_error_list => v_tariff_options_result.sbs_pack_delete_errors
                          )
          ;

          -- определяем признак частичной обработки заказа
          -- либо если тарифные опции не выбраны
          IF v_tariff_options_result.sbs_result_status IN (sc_kernel.GC_ORD_RS_PARTIALLY, sc_kernel.GC_ORD_RS_ERROR) THEN
            v_curr_subs_or_status := sc_cp_orders_pg.set_curr_subs_or_status(
                p_or_status => sc_cp_orders_pg.GC_SUB_OR_PARTIALLY,
                p_savepoint => C_SAVEPOINT
            );
          END IF;
          -- для нового режима накапливаем стоимость начислений на корпоративном счете

          IF v_curr_subs_or_status != sc_cp_orders_pg.GC_SUB_OR_ERROR THEN
            sc_cp_bis_common_pg.add_charge_for_oper_list(
                p_clnt_id     => v_clnt_id,
                p_sum_charges => v_sum_charges_packs,
                p_charge      => v_tariff_options_result.charge_common
            );
          END IF;

          exception
          WHEN others THEN
          -- обрабатываем ошибки с сохранением результата
          /*
          1 - тарифный план не доступен
          2 - у ТП есть обязателные группы без выбранных опций
          */
          IF NOT sc_cp_orders_pg.brake_error_handler(
              p_cpor_id           => p_cpor_id,
              p_sqlcode           => sqlcode,
              p_sqlerrm           => sqlerrm,
              p_critical_err      => v_critical_err,
              p_subs_id           => v_subs_list(v_idx),
              p_clnt_id           => v_clnt_id,
              xml_doc             => v_xml_doc,
              p_subs_order_result => v_order_result.subs_order_result_list
          )
          THEN
            --             прокидываем исключение для критической ошибки (для отката основной транзакции)
            --             raise;
            -- откатываем изменения по текущему абоненту для продолжения обработки по абонентам (ошибка не критическая)
            v_curr_subs_or_status := sc_cp_orders_pg.set_curr_subs_or_status(
                p_or_status => sc_cp_orders_pg.GC_SUB_OR_ERROR,
                p_savepoint => C_SAVEPOINT
            );
          END IF;

        END;
        ----------------------------------------------------------------------
        -- выполняем дополнительные действия по успешно обработанному абоненту
        ----------------------------------------------------------------------
        IF v_curr_subs_or_status != sc_cp_orders_pg.GC_SUB_OR_ERROR THEN
          -- для режима подтверждения...
          -- суммируем стоимость
          v_charge_total := nvl(v_charge_rateplan, 0) + nvl(v_tariff_options_result.charge, 0);
          v_order_result.sum_charge := v_order_result.sum_charge + nvl(
              v_charge_total,
              0
          );

          -- записываем информацию по успешно обработанному абоненту
          v_order_result.subs_order_result_list.extend;
          v_order_result.subs_order_result_list(v_order_result.subs_order_result_list.LAST) :=
          t_sc_cp_subs_order_result_rec(
              subs_id => v_subs_list(v_idx),
              STATUS  => v_curr_subs_or_status,
              detail  => v_xml_detail,
              charge  => v_charge_total
          );

          -- записываем прогресс по успешно обработанным абонентам
          sc_cp_orders_pg.change_order_progress(
              p_cpor_id       => p_cpor_id,
              p_subs_all_cnt  => v_subs_list.COUNT,
              p_subs_curr_cnt => v_ok_subs_count + 1
          );
          IF v_curr_subs_or_status = sc_cp_orders_pg.GC_SUB_OR_OK THEN
            v_ok_subs_count := v_ok_subs_count + 1;
          elsif v_curr_subs_or_status = sc_cp_orders_pg.GC_SUB_OR_PARTIALLY THEN
            v_partial_subs_count := v_partial_subs_count + 1;
          END IF;
        END IF;

        -- переходим к обработке следующего абонента
        v_idx := v_subs_list.NEXT(v_idx);
      END loop;


      -- ===================================================================================================================
      -- формируем/записываем результат заказа
      -- ===================================================================================================================

      --------------------------------------------
      -- формируем идентификатор результата заказа
      --------------------------------------------
      v_result := CASE
                  -- все абоненты обработаны без ошибок
                  WHEN v_ok_subs_count = v_subs_list.COUNT
                    THEN sc_cp_orders_pg.GC_OR_OK

                  -- либо только часть абонентов обработана с ошибками и запрошен был режим "выполнить по всем, кому возможно",
                  -- либо был запрошен режим немедленного выполнения заказа с типом "подтверждение"
                  WHEN (
                         ( v_ok_subs_count > 0 OR v_partial_subs_count > 0)
                         AND v_order.processing_mode = sc_cp_orders_pg.GC_PM_PARTIAL
                       )
                       OR (
                         v_order.cpoh_cpoh_id = GC_HANDL_CONFIRM
                       )
                    THEN sc_cp_orders_pg.GC_OR_PARTIALLY

                  -- в остальных случаях считаем, что заказ не выполнился и все изменения необходимо откатить
                  ELSE sc_cp_orders_pg.GC_OR_ERROR
                  END;

      ----------------------------------------
      -- записываем результат обработки заказа
      ----------------------------------------

      -- получаем результат в виде XML
      sc_cp_orders_pg.get_order_result_as_xml(
          p_order_result => v_order_result,
          p_xml_data     => v_xml_doc
      );

      -- сохраняем XML...
      IF v_result = sc_cp_orders_pg.GC_OR_ERROR THEN
        -- в автономной транзакции, так как далее произойдет откат всех изменений в текущей транзакции
        sc_cp_orders_pg.write_to_clob_auto_trn(
            p_cpor_id => p_cpor_id,
            p_xml_doc => v_xml_doc
        );
      ELSE
        -- в текущей транзакции
        sc_cp_orders_pg.write_to_clob(
            rclob => p_locator,
            tclob => v_xml_doc
        );
      END IF;

      ---------------------------------------------
      -- возвращаем идентификатор результата заказа
      ---------------------------------------------
      RETURN v_result;
    END handl_rp_and_packs_client_bis;

  -- Обрабатывает заказ на изменение ТП (маршрутизатор по типу клиента).
  FUNCTION handl_rate_plan_pack_change(
    p_cpor_id   IN            cp_orders.cpor_id%TYPE,
    p_cpct_id   IN            cp_client_type.cpct_id%TYPE,
    p_bis_id    IN            cp_clients.bis_id%TYPE,
    p_navi_user IN            varchar2,
    p_locator   IN OUT nocopy cp_order_data.xml_data%TYPE
  )
    RETURN NUMBER
  IS
    BEGIN
      RETURN handl_rp_and_packs_client_bis(
          p_cpor_id   => p_cpor_id,
          p_navi_user => p_navi_user,
          p_locator   => p_locator
      );
    END handl_rate_plan_pack_change;

  -- Создает запись зависимости опции от тарифного плана
  -- на выходе возвращает статус:
  -- 0 - зависимость успешно создана;
  -- 1 - не найден тарифный план;
  -- 2 - не найдена опция;
  -- 3 - такая зависимость уже существует.
  FUNCTION connect_pack_to_rtpl(p_rtpl_id  IN sc_business_objects.sbo_id%TYPE,
                                p_pack_id  IN sc_business_objects.sbo_id%TYPE)
    RETURN NUMBER
  IS
    v_rtpl_id sc_business_objects.sbo_id%TYPE;
    v_pack_id sc_business_objects.sbo_id%TYPE;
    v_existed_count NUMBER;
    BEGIN
      BEGIN
        SELECT sbo_id INTO v_rtpl_id FROM sc_business_objects WHERE sbot_sbot_id = 1 AND sbo_id = p_rtpl_id;
        exception
          WHEN NO_DATA_FOUND THEN
          RETURN 1;
      END;
      BEGIN
        SELECT sbo_id INTO v_pack_id FROM sc_business_objects WHERE sbot_sbot_id = 2 AND sbo_id = p_pack_id;
        exception
          WHEN NO_DATA_FOUND THEN
          RETURN 2;
      END;

      SELECT COUNT(*) INTO v_existed_count FROM cp_sbo_to_sbo WHERE sbo_sbo_id = v_pack_id AND sbo_sbo_id_parent = v_rtpl_id;
      IF v_existed_count = 0 THEN
        INSERT INTO cp_sbo_to_sbo(sbo_sbo_id, sbo_sbo_id_parent)
          VALUES (v_pack_id, v_rtpl_id);
        RETURN 0;
      ELSE
        RETURN 3;
      END IF;
    END connect_pack_to_rtpl;

END sc_cp_bis_ord_rateplan_pack_pg;
/