<?php

/**
 *  GENBAND ("GENBAND") CONFIDENTIAL
 *
 *  Copyright (c) 2012-2016 [GENBAND], All Rights Reserved.
 *
 *  NOTICE:  All information contained herein is, and remains the property of GENBAND. The intellectual and technical concepts contained
 *  herein are proprietary to COMPANY and may be covered by U.S. and Foreign Patents, patents in process, and are protected by trade secret or copyright law.
 *  Dissemination of this information or reproduction of this material is strictly forbidden unless prior written permission is obtained
 *  from GENBAND.  Access to the source code contained herein is hereby forbidden to anyone except current GENBAND employees, managers or contractors who have executed
 *
 *  Confidentiality and Non-disclosure agreements explicitly covering such access.
 *
 *  The copyright notice above does not evidence any actual or intended publication or disclosure  of  this source code, which includes
 *  information that is confidential and/or proprietary, and is a trade secret, of  GENBAND.   ANY REPRODUCTION, MODIFICATION, DISTRIBUTION, PUBLIC  PERFORMANCE,
 *  OR PUBLIC DISPLAY OF OR THROUGH USE  OF THIS  SOURCE CODE  WITHOUT  THE EXPRESS WRITTEN CONSENT OF COMPANY IS STRICTLY PROHIBITED, AND IN VIOLATION OF APPLICABLE
 *  LAWS AND INTERNATIONAL TREATIES.  THE RECEIPT OR POSSESSION OF  THIS SOURCE CODE AND/OR RELATED INFORMATION DOES NOT CONVEY OR IMPLY ANY RIGHTS
 *  TO REPRODUCE, DISCLOSE OR DISTRIBUTE ITS CONTENTS, OR TO MANUFACTURE, USE, OR SELL ANYTHING THAT IT  MAY DESCRIBE, IN WHOLE OR IN PART.
 * */

use models\external\prov\exception\CallFailedException;
use models\external\prov\Individual;
use models\external\prov\pa\Pa;
use models\external\prov\Spider;
use models\external\prov\Orecx;
use provisioning\ProvisioningLiveSupportInboundVoice;
use provisioning\ProvisioningMSTeamsSubscriber;
use utilities\constant\SyncInvoiceConstant;
use utilities\Encryption;

require_once(PORTAL_COMMON_BASE_PATH.'utilities/constant/trackit_templates/midatrackittemplates.php');

class SubscriberFacade extends Facade {

    private $_common_fields = array(
        "first_name",
        "last_name",
        "user_id",
        "site_identifier",
        "role",
        "products_details"
    );

    private $_common_prov_fields = array(
        "voip_numbers",
        "timezone",
        "email"
    );

    private $_mep_fields = array(
        "mobile_extension",
        "is_mobile_extension_enabled",
        "mobility_profile"
    );

    private $_voicemail_fields = array(
        "voicemail_emails",
        "voicemail_pin",
        "voicemail_service",
        "voicemail_server",
        "voicemail_number",
        "voicemail_notification"
    );

    private $_meetme_fields = array(
        "meetme_pin",
        "meetme_access_code"
    );

    private $_callgrab_fields = array(
        "callgrab_number"
    );

    private $_voip_fields = array(
        "devices",
        "call_permission",
        "call_forward_permission",
        "location_name",
        "voip_alias",
        "device_password_state",
        "device_password",
		"last_updated_pmc_password_stamp",
        "user_password",
        "mobile_number",
        "home_number",
        "fax_number",
        "public_charge_id",
        "hotdesk_password"
    );

    private $_sip_pbx_routing_fields = array(
        "call_permission",
        "call_forward_permission",
        "location_name",
        "user_password",
        "email",
        "mobile_number",
        "home_number",
        "fax_number",
        "public_charge_id"
    );

    private $_sip_pbx_calling_fields = array(
        "location_name",
        "user_password",
        "email",
        "mobile_number",
        "home_number",
        "fax_number",
        "public_charge_id"
    );

    private $_standalone_voicemail_fields = array(
        "voicemail_system"
    );

    private $_smart_office_fields = array(
        "conference_extn_number"
    );

    private $_site_mep_fields = array(
        "mobility_profile" => "mobile_profile"
    ); // Subscriber field name is different in site field name

    private $_common_prov_over_ride_fields = array(
        "timezone" => "is_timezone_over_ride"
    );

    private $_voip_over_ride_fields = array(
        "call_permission" => "is_call_permission_over_ride",
        "call_forward_permission" => "is_call_forward_permission_over_ride",
        "device_password" => "is_device_password_over_ride",
        "location_name" => "is_location_name_over_ride",
        "public_charge_id" => "is_public_charge_id_over_ride"
    );

    private $_voicemail_over_ride_fields = array(
        "voicemail_service" => "is_voicemail_service_over_ride",
        "voicemail_server" => "is_voicemail_server_over_ride"
    );
    private $_mep_over_ride_fields = array(
        "mobility_profile" => "is_mobile_profile_over_ride"
    );

    private $_standalone_voicemail_over_ride_fields = array(
        "voicemail_system" => "is_voicemail_system_over_ride"
    );

    private $_autogenerated_fields = array(
        "domain",
        "group_id",
        "timezone_id",
        "site_id",
        "sku",
        "product_ids",
        "default_status",
        "service_set_value",
        "subscriber_type",
        "prov_system_id",
        "password",
        "voicemail_account",
        "voicemail_notification",
        "is_mobile_extension_enabled",
        "voice_mail_directory_number",
        "voicemail_device_id",
        "msg_ip_address",
        "smart_office_proxy_id"
    );

    private $_modify_user_fields = array(
        "first_name",
        "last_name",
        "site_identifier",
        "products_details",
        "timezone",
        "email",
        "mobile_number",
        "home_number",
        "fax_number",
        'language'
    );

    private $_modify_hosted_voicemail_fields = array(
        "first_name",
        "last_name",
        "products_details",
        "voice_mail_directory_number",
        "timezone",
        "email",
        "voicemail_emails",
        "voicemail_pin",
        "voicemail_notification",
        "voip_alias",
        "voip_numbers",
        'language'
    );

    private $_modify_premise_voicemail_fields = array(
        "voicemail_server",
        "voicemail_number",
        "voice_mail_directory_number"
    );

    private $_other_error_message;

    public $fromMigration = false;
    public $isDomainChanged = false;

    /**
     * SubscriberFacade constructor.
     */
    public function __construct() {
        // initialization for the Error Logger
        $this->_errorLogger(__CLASS__);
    }

    /**
     * Method to get SMB details
     *
     * @param int $groupID
     *
     * @return array
     */
    public function get_smb_details($groupID)
    {
        return SmbDao::get_smb_detail(DbConnector::getConnection(), $groupID);
    }

    /**
     * Method to build error message template
     *
     * @param int $errorCode
     * @param string $errorMessage
     *
     * @return array
     */
    private static function _build_error_message($errorCode, $errorMessage)
    {
        return [
            'ERROR_CODE' => $errorCode,
            'ERROR_MESSAGE' => $errorMessage
        ];
    }

    /**
     * Method to check translated response
     *
     * @param array $response
     * @param int $errorCode
     * @param string $errorMessage
     *
     * @return void
     * @throws Exception
     */
    private function _check_translated_response($response, $errorCode, $errorMessage = '')
    {
        if (empty($response[ProvisioningConstant::TRANSLATED_ERROR_MESSAGE])) {
            throw new CallFailedException ($errorMessage, $errorCode);
        }

        throw new CallFailedException (
            $response[ProvisioningConstant::TRANSLATED_ERROR_MESSAGE],
            ApiResponseConstant::TRANSLATED_ERROR_MESSAGE
        );
    }

    /**
     * Method to check incompatible and insufficient sku info
     *
     * @param PDO $connection
     * @param array $skuList
     * @param int $parentGroupID
     * @param int $groupID
     *
     * @return array
     */
    private function get_compatible_info($connection, $skuList, $parentGroupID, $groupID)
    {
        $responseArray = [];
        $productIDList = ProductDao::getProductIdListFromSkuList($connection, $skuList, $parentGroupID, $groupID);
        $compatibilityInfoArray = ProductDao::get_product_compatibility_info($connection, $productIDList, true);

        if (!$compatibilityInfoArray['compatible'] && !$compatibilityInfoArray['sufficient']) {
            $responseArray = $this->_build_error_message(ApiResponseConstant::INCOMPATABLE_AND_INSUFFICIENT_PRODUCTS, '');
        } elseif (!$compatibilityInfoArray['compatible']) {
            $responseArray = $this->_build_error_message(ApiResponseConstant::INCOMPATABLE_PRODUCTS, '');
        } elseif (!$compatibilityInfoArray['sufficient']) {
            $responseArray = $this->_build_error_message(ApiResponseConstant::INSUFFICIENT_PRODUCTS, '');
        }

        return $responseArray;
    }

    /** Method to validate product and inventory exist
     * @param $connection
     * @param $products_details
     * @param $group_details
     * @param $old_product_details
     * @return array
     */
    public function _validateProductAndInventory($connection, $products_details, $group_details, $old_product_details) {
        // compatibility and sufficiency check
        $compatible_info = $this->get_compatible_info($connection, $products_details, $group_details->parent_group_id, $group_details->group_id);
        if (array_key_exists("ERROR_CODE", $compatible_info)) {
            return $compatible_info;
        }

        $unassignable_sku_list = ProductDao::get_unassignable_skus($connection, $group_details->parent_group_id, $group_details->group_id);
        foreach ($products_details as $sku) {
            if (UtilityMethods::isNotEmpty($old_product_details) && in_array($sku, $old_product_details)) {
                continue;
            }

            if (is_array($unassignable_sku_list) && count($unassignable_sku_list) > 0) {
                if (in_array($sku, $unassignable_sku_list)) {
                    return $this->_build_error_message(ApiResponseConstant::SKU_UNASSIGNABLE_TO_SUBSCRIBER, $sku);
                }
            }

            // Validate Inventory Quantity Exist.
            $product_quantity = InventoryItemDao::getProductQuantityInInventory($connection, $sku, $group_details->group_id);
            if ($product_quantity <= 0) {
                return $this->_build_error_message(ApiResponseConstant::INSUFFICIENT_INVENTORY, $sku);
            }
        }
    }

    /** Method to get subscriber details
     * @param $user_id
     * @param $group_details
     * @return array|bool
     */
    public function get_subscriber_details($user_id, $group_details) {
        $connection = DbConnector::getConnection();
        $response = $this->_get_subscriber_details($connection, $user_id, $group_details, false);
        return $response;
    }

	/*
	 * if $internal_call = false, then return subscriber details on hierarchy
	 * else in single dimension array with key=> values
	 * This method is used to construct the subscriber details for
	 * 1. get individual subscriber details
	 * 2. delete subscirber details
	 * 3. edit subscriber details (both for before and after update)
	 */
	public function _get_subscriber_details($connection, $user_id, $group_details, $internal_call) {
		$group_id = $group_details->group_id;
		//this array is holding voip numbers that are set as target numbers for the device buttons
		$phone_numbers_set_as_target = array();
		$db_subscriber_details = SubscriberDao::get_subscribers_details ( $connection, $group_details->group_id, $user_id );
		if ($db_subscriber_details === false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Invalid User ID '$user_id' provided..." );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::RESOURCE_NOT_EXISTS;
			return $response_array;
		}
		$db_subscriber_details ['is_eup_advanced_enabled'] = SubscriberDao::get_subscriber_eup_advanced_enabled($connection, $db_subscriber_details['user_id'] ) ['is_eup_advanced_enabled'];
		$subscriber_type = $db_subscriber_details ["subscriber_type"];
		$service_set_value = $db_subscriber_details ["service_set_value"];
		$menu = ProductDao::getSubscriberMenuByServiceSet ( $connection, $service_set_value );
		$subscriber_details = array ();

        $identityDetailsFieldName = [
            'first_name' => 'first_name',
            'last_name' => 'last_name',
            'user_id' => 'user_id',
            'site_identifier' => 'site_identifier',
            'role' => 'role',
            'sso_auth_user_id' => 'sso_auth_user_id',
            'authentication_method' => 'authentication_method',
            'products_details' => null,
            'domain' => 'domain',
            'status' => 'status',
            'default_status' => 'default_status',
            'department' => 'department',
            'aa_sync_status' => 'aa_sync_status',
        ];

		$identity_details = $this->_populate_details ( $identityDetailsFieldName, $db_subscriber_details );
		$identity_details ["products_details"] = explode ( "|", $db_subscriber_details ["sku"] );
		$identity_details ["password_configured"] = FALSE;
		$identity_details ["device_password_configured"] = FALSE;
		$identity_details ["hotdesk_password_configured"] = FALSE;
        $identity_details["voiceMailPinConfigured"] = false;
        $identity_details["trial_support_enabled"] = $db_subscriber_details ["trial_support"];
		$identity_details ["trial_activation"] = $db_subscriber_details ["trial_activation"];
		$identity_details ["service_set_value"] = $service_set_value;
		if (ProvUtility::isSubscriberConfiguredOrStandalone ( $subscriber_type )) {
			$settings_field_name = array ();
			$advanced_settings_field_name = array ();

			$advanced_settings_field_name ["timezone"] = "timezone";
			$settings_field_name ["email"] = "email_address";
			$advanced_settings_field_name["selected_language"] = "language";

			if (ProvUtility::isSubscriberConfigured ( $subscriber_type )) {
				$settings_field_name ["mobile_number"] = "mobile_number";
				$settings_field_name ["home_number"] = "home_number";
				$settings_field_name ["fax_number"] = "fax_number";
                $settings_field_name['allow_eup_config'] = 'is_phonebutton_enabled';
                $settings_field_name['callgrab_number'] = 'call_grab_number';

				$advanced_settings_field_name ["call_permission"] = "call_permission";
				$advanced_settings_field_name ["call_forward_permission"] = "call_forward_permission";
				$advanced_settings_field_name ["location_name"] = "location_name";
				$advanced_settings_field_name ["public_charge_id"] = "public_charge_id";
				$advanced_settings_field_name ["voip_alias"] = "voice_alias";
				$advanced_settings_field_name ["device_password_state"] = "device_password_state";
                $advanced_settings_field_name ["is_eup_advanced_enabled"] = "is_eup_advanced_enabled";
				$identity_details ["password_configured"] = TRUE;
                if (UtilityMethods::isNotEmpty($db_subscriber_details["voicemail_pin"])) {
                    $identity_details["voiceMailPinConfigured"] = true;
                }
				if (UtilityMethods::isNotEmpty ( $db_subscriber_details ["device_password"] ) && ProvUtility::isValidDevicePasswordStateUser ( $db_subscriber_details ["device_password_state"] )) {
					$identity_details ["device_password_configured"] = TRUE;
				}
				if (UtilityMethods::isNotEmpty ( $db_subscriber_details ["hotdesk_password"] )) {
					$identity_details ["hotdesk_password_configured"] = TRUE;
				}

				if (UtilityMethods::is_meetme_menu_bundle ( $menu )) {
					$advanced_settings_field_name ["meetme_access_code"] = "meetme_access_code";
					$settings_field_name ["meetme_pin"] = "meetme_pin";
				}
				if (UtilityMethods::is_mobility_menu_bundle ( $menu )) {
					$settings_field_name ["mobile_extension"] = "is_mobile_extension_enabled";
					$advanced_settings_field_name ["mobility_profile"] = "mobile_profile";
				}
				if (UtilityMethods::is_callgrab_menu_bundle ( $menu )) {
					$settings_field_name ["callgrab_number"] = "call_grab_number";
				}
				if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
					$advanced_settings_field_name ["conference_extn_number"] = "collab_access_code";
				}
			} // end of if(subscriber = CONFIGURED)

			if (UtilityMethods::is_voicemail_menu_bundle($menu)) {
				$a2_vm_pin = $this->_get_vm_pin_on_a2($connection, $db_subscriber_details, $group_details);

				if (UtilityMethods::isNotEmpty($a2_vm_pin)) {
					// check whether voicemail pin is updated or not
					if (UtilityMethods::isNotEqual($a2_vm_pin, $db_subscriber_details["voicemail_pin"])) {
                        $encryption = new Encryption(CommonConstant::CIPHER_AES_CBC_256, VOICEMAIL_PIN_ENCRYPTION_KEY);

						Dao::updateBasedOnGivenKey($connection, "subscriber_service_details", array(
							"subscriber_id" => $db_subscriber_details["subscriber_id"]
                        ), [
                            'voicemail_pin' => $encryption->encrypt($a2_vm_pin)
                        ]);
						$db_subscriber_details["voicemail_pin"] = $a2_vm_pin;
					}
					$this->_update_ureach_voicemail_emails($connection, $db_subscriber_details, $group_details);
					$settings_field_name["voicemail_emails"] = "voicemail_notification";
					$settings_field_name["voicemail_pin"] = "voicemail_pin";
				}
				$advanced_settings_field_name["voicemail_service"] = "voicemail_service";
				$advanced_settings_field_name["voicemail_server"] = "voicemail_server";
				$advanced_settings_field_name["voicemail_number"] = "voicemail_number";
			}

			$settings_field_name ["campaign_number"] = "campaign_number";
            $settings_field_name ['destination'] = 'destination';
            $settings_field_name ['force_tokenized_identity'] = 'force_tokenized_identity';
            $settings_field_name ['call_me_auth_token_id'] = 'call_me_auth_token_id';
            $settings_field_name['call_me_auth_token_name'] = 'call_me_auth_token_name';

			$settings = $this->_populate_details ( $settings_field_name, $db_subscriber_details );
			$advanced_settings = $this->_populate_details ( $advanced_settings_field_name, $db_subscriber_details );
			if (array_key_exists ( "device_password_state", $advanced_settings ) && UtilityMethods::isEmpty ( $advanced_settings ["device_password_state"] )) {
				$advanced_settings ["device_password_state"] = ProvisioningConstant::DEVICE_PASSWORD_STATE_NONE;
			}
            if (ProvUtility::isSubscriberConfigured($subscriber_type)
                || ProvUtility::isTypeStandaloneAndServiceSetImmLs($db_subscriber_details)
                || ProvUtility::isTypeStandaloneAndServiceSetMsTeams($db_subscriber_details)) {
			   $phone_numbers_set_as_target = $this->get_device_buttons_target_numbers($connection, $db_subscriber_details['user_id'], $group_details->group_id);
			    if(isset( $phone_numbers_set_as_target)){
			        $settings["target_numbers"] = $phone_numbers_set_as_target;
			    }
				$pstndid_array = PstndidDao::get_pstn_did_numbers_for_subscriber ( $connection, $db_subscriber_details ["subscriber_id"] );
				$settings ["voip_numbers"] = array ();
				if (UtilityMethods::isNotEmpty ( $pstndid_array )) {
					$settings ["voip_numbers"] = $pstndid_array;
					if (! $internal_call && UtilityMethods::isEmpty ( $advanced_settings ["public_charge_id"] )) {
                        $publicNumberPrefix = (new PSXFacade())->isPSXEnabled($group_id) ? PSXConstant::E164_NUMBER_PREFIX : '';
                        $advanced_settings ["public_charge_id"] = $publicNumberPrefix . $settings["voip_numbers"][0];
					}
				}
				$terminal_list = TerminalsDao::get_subscriber_terminal_list ( $connection, $db_subscriber_details ["subscriber_id"] );
				$generic_device_list = GenericDeviceDao::get_subscriber_generic_devices_list ( $connection, $db_subscriber_details ["subscriber_id"], "mac_address");
				$terminal_list =array_merge($terminal_list, $generic_device_list);
                $settings ["devices"] = UtilityMethods::array_column ( $terminal_list, 'mac_address' );
                if(isset($settings ["devices"] )){
                    $settings['mac_with_paging'] = array();
                    foreach($settings["devices"] as $mac){
                        $terminal_id = TerminalsDao::get_terminal_id_by_mac($connection,$mac);
                        if (UtilityMethods::isNotEmpty($terminal_id)) {
                            $terminalWithPaging = PagingGroupDao::check_terminal_id_exist($connection, $terminal_id);
                            if (UtilityMethods::isNotEmpty($terminalWithPaging)) {
                                array_push($settings['mac_with_paging'], $mac);
                            }
                        }
                    }

                }
				if(isset($settings ["devices"]) && is_array($settings ["devices"])){
                    $devices_with_buttons = DeviceButtonsDao::get_all_macs_with_provisioned_buttons($connection, $settings ["devices"]);
					$devices_with_buttons_set= UtilityMethods::array_column ( $devices_with_buttons, 'mac_address' );
					$devices_with_soft_keys = DeviceButtonsDao::get_all_macs_with_soft_keys($connection, $settings ["devices"]);
					$devices_with_soft_keys_set = UtilityMethods::array_column ( $devices_with_soft_keys, 'mac_address' );
					$settings["devices_with_buttons_set"] = array_merge($devices_with_soft_keys_set,$devices_with_buttons_set );

                }

				if (! empty ( $db_subscriber_details ["client_type_id"] )) {
					$client_type = ClientConfigurationDao::get_catalog_client_type_by_id ( $connection, $db_subscriber_details ["client_type_id"] ) ["client_type"];
					$settings ["client_type_id"] = $db_subscriber_details ["client_type_id"];
					$settings ["client_type"] = $client_type;
				}

				if (UtilityMethods::is_mobility_menu_bundle ( $menu )) {
					if ($settings ["mobile_extension"] == 1) {
						$settings ["mobile_extension"] = CommonConstant::ENABLE;
					} else {
						$settings ["mobile_extension"] = CommonConstant::DISABLE;
					}
				}

                if (UtilityMethods::isMsTeamsMenuBundle($menu)) {
                    $msSubDetail = MsTeamsSubscriberDao::getBySubscriberID($connection, $db_subscriber_details['subscriber_id']);
                    if (!array_key_exists('ERROR_CODE', $msSubDetail)) {
                        $settings["ms_teams_id"] = $msSubDetail['ms_teams_id'];
                        include_once('/var/www/html/prov/lib/apis/msteams/MSTeamsClient.php');
                        $account = MsTeamsAccountDao::getByGroupId($connection, $group_id);
                        $teamsClient = new MSTeamsClient(
                            $account['cpaas_account_identifier'],
                            $account['cpaas_endpoint_identifier']
                        );

                        $subscribersObject = [['user' => $msSubDetail['ms_teams_id']]];
                        $delta = $teamsClient->getDelta($subscribersObject);
                        $deltaArr = json_decode(json_encode($delta), true);
                        $settings['ms_teams_delta_status'] = strtolower(preg_replace('/(?<!^)[A-Z]/', '_$0', $deltaArr[0]['status']));
                        $settings["ms_teams_carrier_name"] = $msSubDetail['name'];

                        $settings['ms_teams_emergency_details_available'] = MS_TEAMS_EMERGENCY_ADDRESS_AVAILABLE;
                    }
                }

				if (! $internal_call && count ( $settings ["voip_numbers"] ) > 0 && UtilityMethods::is_meetme_menu_bundle ( $menu )) {
					// meetme details may have been set on legacy PA more recently than subscriber was updated in our DB
					$mas_details = $this->_get_and_update_meetme_details_from_mas($connection, $db_subscriber_details["subscriber_id"], $db_subscriber_details["user_id"],
														$db_subscriber_details["meetme_pin"], $db_subscriber_details["meetme_access_code"], $db_subscriber_details["age"]);
					$advanced_settings ["meetme_access_code"]  = $mas_details["meetme_access_code"];
					$settings ["meetme_pin"] = $mas_details["meetme_pin"];

					if (UtilityMethods::isEmpty ( $advanced_settings ["meetme_access_code"] )) {
						$advanced_settings ["meetme_access_code"] = substr($settings ["voip_numbers"] [0],-10);
					}
					if (UtilityMethods::isEmpty ( $settings ["meetme_pin"] )) {
						// never autogenerate a PIN value here. Leave it empty
					}
				}
			}
            $advanced_settings ['is_eup_advanced_enabled'] = ($db_subscriber_details ['is_eup_advanced_enabled']== 1 ? 'enabled' : 'disabled');
			if (UtilityMethods::is_voicemail_menu_bundle ( $menu )) {
				if (isset ( $settings ["voicemail_emails"] ) && UtilityMethods::isEqual ( $settings ["voicemail_emails"], ProvisioningConstant::VOICEMAIL_NOTIFICATION_ALWAYS )) {
					$settings ["voicemail_emails"] = CommonConstant::ENABLE;
				} else {
					$settings ["voicemail_emails"] = CommonConstant::DISABLE;
				}

				if (UtilityMethods::is_standalone_voicemail_menu_bundle ( $menu )) {
					$voicemail_device_details = VoicemailDeviceDao::get_voicemail_devices_details_by_id ( $connection, $db_subscriber_details ["voicemail_device_id"], $group_id );
					if (UtilityMethods::isNotEmpty ( $voicemail_device_details )) {
						$advanced_settings ["voicemail_system"] = $voicemail_device_details->alias;
					}
					$settings ["voip_numbers"] = array ();
					if (UtilityMethods::isNotEmpty ( $db_subscriber_details ["voice_mail_directory_number"] )) {
						$settings ["voip_numbers"] = explode ( ",", $db_subscriber_details ["voice_mail_directory_number"] );
					}
				}
				if (! $internal_call && is_array ( $settings ["voip_numbers"] ) && count ( $settings ["voip_numbers"] ) > 0) {
					if (ProvUtility::isVoicemailServicePermise ( $db_subscriber_details ["voicemail_service"] ) && UtilityMethods::isEmpty ( $advanced_settings ["voicemail_number"] )) {
						$advanced_settings ["voicemail_number"] = $settings ["voip_numbers"] [0];
					}
				}
			} // end of if (ss=VoiceMail)

			if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
				$smart_office_group_id = $this->_get_smart_office_group_id ( $group_details );
				$advanced_settings ['conference_extn_prefix'] = SmartOfficeConfigurationDao::get_conference_access_prefix ( $connection, $smart_office_group_id, ProvisioningConstant::SMART_OFFICE_VIDEO_COLLAB );
				$advanced_settings ['conference_extn_with_prefix'] = $advanced_settings ['conference_extn_prefix'] . $db_subscriber_details ["collab_access_code"];
			} // end of if (ss=smart_office_video_collab)

            $emergencyAddress =  SubscriberAddressDao::getBySubscriberId($connection, $db_subscriber_details['subscriber_id']);
            if (!empty($emergencyAddress)) {
                $subscriber_details ["emergencyAddress"] = $emergencyAddress;
            }

			$subscriber_details ["settings"] = $settings;
			$subscriber_details ["advanced_settings"] = $advanced_settings;
		}  // end of if(subscriber = CONFIGURED OR SS)
		else if (ProvUtility::isSubscriberSipTrunk ( $subscriber_type )) {
			$settings_field_name = array ();
			$pstndid_array = PstndidDao::get_pstn_did_numbers_for_subscriber ( $connection, $db_subscriber_details ["subscriber_id"] );
			$settings ["voip_numbers"] = array ();
			if (UtilityMethods::isNotEmpty ( $pstndid_array )) {
				$settings ["voip_numbers"] = $pstndid_array;
			}

			if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
				$advanced_settings_field_name = array ();
				$settings_field_name ["mobile_number"] = "mobile_number";
				$settings_field_name ["home_number"] = "home_number";
				$settings_field_name ["fax_number"] = "fax_number";
				$settings_field_name ["email"] = "email_address";
				$advanced_settings_field_name ["timezone"] = "timezone";
				if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu )) {
					$advanced_settings_field_name["selected_language"] = "language";
					$advanced_settings_field_name ["call_permission"] = "call_permission";
					$advanced_settings_field_name ["call_forward_permission"] = "call_forward_permission";
				}
				$advanced_settings_field_name ["location_name"] = "location_name";
				$advanced_settings_field_name ["public_charge_id"] = "public_charge_id";
				$identity_details ["password_configured"] = TRUE;

				$advanced_settings = $this->_populate_details ( $advanced_settings_field_name, $db_subscriber_details );
				if (! $internal_call && UtilityMethods::isEmpty ( $advanced_settings ["public_charge_id"] ) && count ( $settings ["voip_numbers"] ) > 0) {
                    $publicNumberPrefix = (new PSXFacade())->isPSXEnabled($group_id) ? PSXConstant::E164_NUMBER_PREFIX : '';
                    $advanced_settings ["public_charge_id"] = $publicNumberPrefix . $settings["voip_numbers"][0];
				}

				$subscriber_details ["advanced_settings"] = $advanced_settings;

				$routing_settings = $this->_populate_details ( $settings_field_name, $db_subscriber_details );
				$settings = array_merge ( $settings, $routing_settings );
			}
			$subscriber_details ["settings"] = $settings;
		} // end of if(subscriber = SIP_TRUNK)

		if ($group_details->allow_multiple_prov_system) {
			$provision_system_id = ProvisionSystemDao::get_provSystem_list_by_identifier ( $connection, $group_details->group_identifier, $db_subscriber_details ["prov_system_id"] );
			$identity_details ["provisioning_system"] = $provision_system_id;
		}

		$subscriber_details ["identity_details"] = $identity_details;
		if (ProvUtility::isSubscriberConfiguredOrStandaloneOrSipTrunk ( $subscriber_type )) {
			$subscriber_details ['service_access_status'] = $db_subscriber_details ['service_access_status'];
		}

		$contact_center_details = $this->get_contact_center_people_details ( $subscriber_details ["identity_details"] ["user_id"] );
		$subscriber_details ["contact_center_details"] = $contact_center_details;
        $subscriber_details['subscriber_type'] = $subscriber_type;

		if ($internal_call) {
			$internal_field_name = array (
					"group_id",
					"site_id",
					"site_alias_prefix",
					"sku",
					"product_ids",
					"service_set_value",
					"default_status",
					"subscriber_type",
					"prov_system_id",
					"subscriber_id",
					"voicemail_account",
					"service_access_status"
			);
			if (ProvUtility::isSubscriberConfiguredOrStandalone ( $subscriber_type ) || UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
				$internal_field_name [] = "timezone_id";
				$internal_field_name [] = "password";
				$internal_field_name [] = "voice_mail_directory_number";
			}
			if (ProvUtility::isSubscriberConfigured ( $subscriber_type )) {
				$internal_field_name [] = "device_password";
			}
			if (UtilityMethods::is_voicemail_menu_bundle ( $menu )) {
				$internal_field_name [] = "voicemail_notification";
				$internal_field_name [] = "msg_ip_address";
			}
			if (UtilityMethods::is_standalone_voicemail_menu_bundle ( $menu )) {
				$internal_field_name [] = "voicemail_device_id";
			}
			if (UtilityMethods::is_mobility_menu_bundle ( $menu )) {
				$internal_field_name [] = "is_mobile_extension_enabled";
				if ($this->_is_field_empty ( $db_subscriber_details, "is_mobile_extension_enabled" )) {
					$db_subscriber_details ["is_mobile_extension_enabled"] = 0;
				}
			}
			if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu ) || UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
				$internal_field_name [] = "smart_office_proxy_id";
			}
			$internal_field_name = array_combine ( $internal_field_name, $internal_field_name );

			// To be done after array_combine, so we can have different UI field and DB field name
			if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu )) {
				$internal_field_name ["conference_extn_number"] = "collab_access_code";
			}

			$internal_field = $this->_populate_details ( $internal_field_name, $db_subscriber_details );
			if (isset ( $internal_field ["password"] )) {
				$internal_field ["user_password"] = UtilityMethods::sip_data_out ( $internal_field ["password"] );
			}
			if (isset ( $internal_field ["hotdesk_password"] )) {
				if (UtilityMethods::isEmpty ( $internal_field ["hotdesk_password"] )) {
					$internal_field ["hotdesk_password"] = NULL;
				}
			}

			if (isset ( $internal_field ["device_password"] )) {
				if (UtilityMethods::isEmpty ( $internal_field ["device_password"] )) {
					$internal_field ["device_password"] = NULL;
				}
			}
			$internal_field ["menu"] = $menu;

			$subscriber_details = $this->_flatten_parameter ( $subscriber_details );
			$subscriber_details = array_merge ( $subscriber_details, $internal_field );
		} // end of if($internal_call)
        if (UtilityMethods::isCallRecordingServiceBundleWithoutLS($service_set_value)) {
            $roleID = CallRecordingRoleDao::getRoleIDByUserID($connection, $user_id);
            if (!empty($roleID)) {
                $roleName = CallRecordingRoleDao::getRoleNameByRoleID($connection, $roleID);
                $subscriber_details["callRecordingData"]["securityGroup"] = $roleName;
            }
            $orecxUserID = CallRecMemberDao::get_call_recording_xid($connection, $user_id);
            if (!empty($orecxUserID)) {
                $orecxProv = new models\external\prov\Orecx();
                $childOrganizationalGroups = $this->getOrganizationalGroupNames($group_id);
                $userParentGroups = $orecxProv->getUserDetails(
                    $connection,
                    $db_subscriber_details,
                    $orecxUserID,
                    true
                );
                $organizationalGroups = [];
                foreach ($childOrganizationalGroups["objects"] as $groups) {
                    foreach ($userParentGroups["parentGroupDtos"] as $userGroups) {
                        if ($userGroups["id"] == $groups["id"]) {
                            array_push($organizationalGroups, $userGroups);
                        }
                    }
                }
                $subscriber_details["callRecordingData"]["organizationalGroups"] = $organizationalGroups;
            }
        }

        if (UtilityMethods::isSoForSfdcSubscriberBundle($service_set_value)) {
            $sfdcFacade = new SfdcFacade();
            $sfSubscriber = $sfdcFacade->getSubscriberByUserID($user_id);
            $subscriber_details['settings']['sfdc_email'] = $sfSubscriber['sf_user_email'];
        }
        $profile = CTBSDao::getCTBSProfileByGroup($connection, $group_id, 'is_schedule_enabled');
        if (!empty($profile)) {
            $ctbsFacade = new CTBSFacade();
            $subscriber_details['settings']['authorization_code'] = $ctbsFacade->getSubscriberAuthorizationCode($user_id);
            $subscriberCTBS = $ctbsFacade->getCTBSForSubscriber($user_id, $group_id);
            $subscriber_details['settings']['scheduled_call_restriction'] = $this->_handleSubscriberCTBS($subscriberCTBS);
        }

        return $subscriber_details;
    }

    /** Takes a list of subscriber names and initiates a check sync.
     *
     * @param array $list_of_subscribers
     * @return array
     * @throws Exception
     */
    public function check_sync_for_list_of_subscribers($list_of_subscribers) {
        try {
            /* TODO: It would be nice to get the list of subscriber IDs from the client.
               TODO: Then we can eliminate this function and use the one in facade.
            */
            $connection = DbConnector::getConnection();
            $list_of_subscriber_ids = array();
            $group_id = CommonHelper::getContextValue('group_id');
            $group_domain = CommonHelper::getContextValue("top_level_domain");
            foreach ($list_of_subscribers as $user_id) {
                $user_id_at_domain = $user_id . '@' . $group_domain;
                $list_of_subscriber_ids[] = SubscriberDao::get_subscriber_details_by_user_id($connection, $user_id_at_domain, $group_id, 'subscriber_id')['subscriber_id'];
            }
            return parent::check_sync_for_list_of_subscribers($list_of_subscriber_ids);
        } catch (Exception $e) {
            if ($this->_isErrorEnabled()) {
                $this->_error("Device fetch failed!", $e);
            }
            throw $e;
        }
    }

    /** Takes a list of subscriber names and initiates a check sync scheduler
     *
     * @param array $check_sync_scheduler_info
     * @return string
     * @throws Exception
     */
    public function check_sync_scheduler_for_list_of_subscribers($check_sync_scheduler_info) {
        try {
            $check_sync = new CheckSyncFacade();
            $response = $check_sync->insert_scheduled_time_for_check_sync($check_sync_scheduler_info);
            return $response;
        } catch (Exception $e) {
            if ($this->_isErrorEnabled()) {
                $this->_error("Device fetch failed!!", $e);
            }
            throw $e;
        }
    }

    /** Method to synchronize all devices of subscriber
     *
     * @param string $subscriber_user_id
     * @param int $group_id
     * @return array
     * @throws Exception
     */
    public function check_sync($subscriber_user_id, $group_id) {

        $connection = DbConnector::getConnection();
        $subscriber_details = SubscriberDao::get_subscriber_details_by_user_id($connection, $subscriber_user_id, $group_id, "subscriber_id, password, domain, prov_system_id");

        if ($subscriber_details == false) {
            $response["ERROR_CODE"] = ApiResponseConstant::SUBSCRIBER_USER_ID_NOT_EXIST;
            if ($this->_isDebugEnabled()) {
                $this->_debug("Check Sync Error : Subscriber which has id " . $subscriber_details['subscriber_id'] . " does not exist.");
            }

            return $response;
        }

        $list_of_subscriber_ids = array();
        $list_of_subscriber_ids[] = SubscriberDao::get_subscriber_details_by_user_id($connection, $subscriber_user_id, $group_id, 'subscriber_id')['subscriber_id'];

        return parent::check_sync_for_list_of_subscribers($list_of_subscriber_ids);
    }

    /** Method to check subscriber device
     *
     * @param string $user_id
     * @return bool
     */
    public function check_subscriber_device($user_id) {
        $connection = DbConnector::getConnection();
        $group_id = CommonHelper::getContextValue('group_id');
        $subscriber_id = SubscriberDao::get_subscriber_details_by_userid($connection, $user_id, $group_id, "subscriber_id");
        $sub_mac = TerminalsDao::get_subscriber_terminal_list($connection, $subscriber_id);
        $sub_gen_mac = GenericDeviceDao::get_subscriber_generic_devices_list($connection, $subscriber_id, "mac_address");
        $sub_mac = array_merge($sub_mac, $sub_gen_mac);

        if (!empty($sub_mac)) {
            return true;
        }
        return false;
    }

    /** Method to update email notification from GetPhoneSetting call and sync with portal db
     *
     * @param $connection
     * @param array $subscriber_details
     * @param array $group_details
     */
    public function _update_ureach_voicemail_emails($connection, &$subscriber_details, $group_details) {

        if (ProvUtility::isUreachDeviceType($group_details->voice_mail_device_type)) {
            $paProv = new Pa();
            $getPhoneSettingsResponse = $paProv->GetPhoneSettings($connection, $subscriber_details);

            $vm_notification = $subscriber_details['voicemail_notification'];
            $vm_email = $subscriber_details["email_address"];

            if (UtilityMethods::isNotEmpty($getPhoneSettingsResponse["RequestedSettings"])) {
                $requestedSettings = $getPhoneSettingsResponse["RequestedSettings"];
                $emailNotification = $requestedSettings["emailNotification"];
                $transcribeNotification = $requestedSettings["transcribeNotification"];

                if (isset($emailNotification["emailAddress"]) && trim($emailNotification["emailAddress"]) !== ""
                    && isset($emailNotification["status"])) {

                    $vm_notification = UtilityMethods::isEqual($emailNotification["status"], CommonConstant::ENABLE)
                        ? ProvisioningConstant::VOICEMAIL_NOTIFICATION_ALWAYS
                        : ProvisioningConstant::VOICEMAIL_NOTIFICATION_OFF;

                    $vm_email = $emailNotification["emailAddress"];
                } elseif (isset($transcribeNotification["emailAddress"]) && trim($transcribeNotification["emailAddress"]) !== ""
                    && isset($transcribeNotification["status"])) {
                    // fix for Jira ACL-6240 Voicemail Email Notifcations Cannot Save as Enabled
                    // if emailNotification is not set in transcribeNotification
                    // we can also see if voicemail emails enabled or disabled
                    $vm_notification = UtilityMethods::isEqual($transcribeNotification["status"], CommonConstant::ENABLE)
                        ? ProvisioningConstant::VOICEMAIL_NOTIFICATION_ALWAYS
                        : ProvisioningConstant::VOICEMAIL_NOTIFICATION_OFF;

                    $vm_email = $transcribeNotification["emailAddress"];
                }

                if (UtilityMethods::isNotEqual($vm_notification, $subscriber_details["voicemail_notification"])) {
                    Dao::updateBasedOnGivenKey(
                        $connection,
                        "subscriber_service_details",
                        array("subscriber_id" => $subscriber_details["subscriber_id"]),
                        array("voicemail_notification" => $vm_notification)
                    );
                    $subscriber_details["voicemail_notification"] = $vm_notification;
                }

                if (UtilityMethods::isNotEqual($vm_email, $subscriber_details["email_address"])) {
                    Dao::updateBasedOnGivenKey(
                        $connection,
                        "subscriber",
                        array("subscriber_id" => $subscriber_details["subscriber_id"]),
                        array("email_address" => $vm_email)
                    );

                    $subscriber_details["email_address"] = $vm_email;
                }
            }
        }
    }

	private function _populate_details($param_field_names, $subscriber_details) {
		$response_array = array ();
		foreach ( $param_field_names as $param_name => $subscriber_name ) {
			if (isset ( $subscriber_details [$subscriber_name] )) {
				$response_array [$param_name] = $subscriber_details [$subscriber_name];
			} else {
				$response_array [$param_name] = null;
			}
		}
		return $response_array;
	}

    /**
     * @param array $param_array
     * @param object $group_details
     * @param string $subscriber_type
     *
     * @return array
     * @throws Exception
     */
	public function save_node_subscriber_details($param_array, $group_details, $subscriber_type)
    {
		$response_array = [];
        if($this->isItOperation()) {
            if($this->_isDebugEnabled()){
                $this->_debug(" Site Facade -> Could not insert site. You do not have sufficient permissions");
            }
            $response_array["ERROR_CODE"] = ApiResponseConstant::IT_OPERATIONS_PERMISSION_RULE;
            return $response_array;
        }
		$connection = DbConnector::getConnection ();
		$subscriber_details = $this->_flatten_parameter ( $param_array );
		// unset all autogenerated fields as client might have it as part of their request as well.
		$this->_reset_fields ( $subscriber_details, $this->_autogenerated_fields );
		$user_id = $subscriber_details ["user_id"];

		if (! ProvUtility::isSubscriberNodType ( $subscriber_type )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber type provided by user is invalid..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS;
			return $response_array;
		}
		$subscriber_details['authentication_method'] = strtoupper($subscriber_details['authentication_method']);
        $subscriber_details['domain'] = $group_details->top_level_domain;
        $subscriber_details['group_id'] = $group_details->group_id;
        $subscriber_details['user_id'] = UtilityMethods::get_subscriber_id($user_id) . '@' . $group_details->top_level_domain;
        $subscriber_details['subscriber_type'] = $subscriber_type;
        $subscriber_details['default_status'] = ProvisioningConstant::DEFAULT_STATUS_ACTIVE;
        $subscriber_details['authentication_method'] = SubscriberConstant::AUTHENTICATION_METHOD_BASIC;

		$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $subscriber_details ["site_identifier"] );
		if ($site_service_information === false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Site Identifier provided by user is invalid..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::SITE_IDENTIFIER_NOT_EXIST;
			return $response_array;
		}
		$subscriber_details ["site_id"] = $site_service_information ["site_id"];

		// validate product and inventory exist
		$response_array = $this->_validateProductAndInventory ( $connection, $subscriber_details ["products_details"], $group_details, NULL );
		if (is_array ( $response_array ) && array_key_exists ( "ERROR_CODE", $response_array )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Products provided by user are invalid...(" . $response_array ["ERROR_CODE"] . ") - " . $user_id );
			}
			return $response_array;
		}

		$product_details = ProductDao::getSubscriberProductDetailsForSkus ( $connection, $subscriber_details ["products_details"], $group_details->parent_group_id, $group_details->group_id );
		if ($product_details === false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Products provided by user are invalid..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS;
			$response_array ["ERROR_MESSAGE"] = "products_details";
			return $response_array;
		}
		unset ( $subscriber_details ["products_details"] );
		$subscriber_details ["sku"] = $product_details ["skus"];
		$subscriber_details ["product_ids"] = $product_details ["product_ids"];
		$subscriber_details ["service_set_value"] = $product_details ["service_set_values"];
		$subscriber_details ["menu"] = $product_details ["menu"];

		if (UtilityMethods::isEmpty ( $subscriber_details ["service_set_value"] )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Service Set is empty for NOD Subscriber Products provided by user are invalid..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS;
			$response_array ["ERROR_MESSAGE"] = "products_details";
			return $response_array;
		}

		if ($this->is_duplicate_userid ( $connection, $subscriber_details ["user_id"], $subscriber_details ["domain"] )) {
			$recommended_user_id = $this->recommend_user_id ( $connection, $subscriber_details ["user_id"], $subscriber_details ["domain"] );
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "User Id already exist..." . $user_id . ", recommended user id is:" . $recommended_user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::SUBSCRIBER_USER_ID_ALREADY_EXIST_ACROSS_PORTAL;
			$response_array ["suggested_user_id"] = $recommended_user_id;
			return $response_array;
		}
		if ($this->_is_field_empty ( $subscriber_details, "timezone" )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Field Timezone is mandatory ..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::MISSING_REQUIRED_PARAMETERS;
			$response_array ["ERROR_MESSAGE"] = "timezone";
			return $response_array;
		}
		$timezone_id = TimezoneDao::get_timezone_id_by_name ( $connection, $subscriber_details ["timezone"] );
		if ($timezone_id == false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Timezone provided by user is invalid..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS;
			$response_array ["ERROR_MESSAGE"] = "timezone";
			return $response_array;
		}
		$subscriber_details ["timezone_id"] = $timezone_id;

		if ($this->_is_field_empty ( $subscriber_details, "user_password" )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "User Password provided by user is invalid..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::MISSING_REQUIRED_PARAMETERS;
			$response_array ["ERROR_MESSAGE"] = "user_password";
			return $response_array;
		}
		$subscriber_password = $subscriber_details ["user_password"];
		$encrypt_password = UtilityMethods::sip_data_in ( $subscriber_password );
		if (is_array ( $encrypt_password ) && array_key_exists ( 'error', $encrypt_password )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Password Encrypt failed for user..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS;
			$response_array ["ERROR_MESSAGE"] = "user_password";
			return $response_array;
		}
		$subscriber_details ["password"] = $encrypt_password;
		$subscriber_details ["prov_system_id"] = $this->get_provisioning_system_id ( $connection, $group_details->group_id );

		$group_domain = $group_details->top_level_domain;
		if (UtilityMethods::isSMB ( $group_details->group_type )) {
			$group_domain = $group_details->smb_prefix . "." . $group_details->top_level_domain;
		}

		try {
			$connection->beginTransaction ();
			if (ProvUtility::isDefaultStatusActive ( $subscriber_details ["default_status"] )) {
				SubscriberDao::insert_subscriber_invoice_details ( $connection, $subscriber_details, ReportConstant::SUBSCRIBER_INVOICE_ADDED_STATUS, $group_domain, ProvUtility::getPstnDidGroupId ( $group_details ) );
			}

			$subscriber_details ["trial_expiry_action"] = "NOTIFY";

			$subscriber_id = SubscriberDao::insert_subscriber ( $connection, $subscriber_details );
			$subscriber_details ["subscriber_id"] = $subscriber_id;
			$this->_add_remove__subscriber_notices ( $connection, $group_details->group_id );

			$individualProv = new models\external\prov\Individual ();
            $response = $individualProv->addUser(
                $connection,
                $group_details,
                $subscriber_details,
                $site_service_information,
                true
            );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> save_subscriber_details failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_add_user_error_response($response);
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED );
			}
			DbConnector::commitTransaction ( $connection );
			return $subscriber_details;
		} catch ( Exception $e ) {
			DbConnector::rollbackTransaction ( $connection );
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Creating Subscriber Failed!", $e );
			}
			// throw $e;
			$response_array ["ERROR_CODE"] = ApiResponseConstant::UNABLE_TO_ADD_SUBSCRIBER;
			if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
				return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
			}
			return $response_array;
		}
	}

    /** Method to save subscriber details
     * @param array $param_array
     * @param object $group_details
     * @param bool $isReset
     *
     * @return array|bool|mixed|number[]
     * @throws Exception
     */
    public function save_subscriber_details($param_array, $group_details, $isReset = null) {
        $this->_debug("# save_subscriber_details");

		$response_array = array ();

		if($this->isItOperation()) {
            if($this->_isDebugEnabled()){
                $this->_debug(" Site Facade -> Could not insert site. You do not have sufficient permissions");
            }
            $response_array["ERROR_CODE"] = ApiResponseConstant::IT_OPERATIONS_PERMISSION_RULE;
            return $response_array;
        }
		$connection = DbConnector::getConnection ();

        // This is for multi-email support in DB and CIM. Getting first email for other systems.
        $param_array["settings"]["emails"] = $param_array["settings"]["email"] ?? '';
        $param_array["settings"]["email"] = trim(explode(",", $param_array["settings"]["email"])[0] ?? '');

		$subscriber_details = $this->_flatten_parameter ( $param_array );

		// unset all autogenerated fields as client might have it as part of their request as well.
        if (!$this->fromMigration) {
            $this->_reset_fields($subscriber_details, $this->_autogenerated_fields);
        }

		$user_id = UtilityMethods::get_subscriber_id($subscriber_details ["user_id"]);
		$subscriber_details ["domain"] = $group_details->top_level_domain;
		$subscriber_details ["group_id"] = $group_details->group_id;
		$subscriber_details ["user_id"] = $user_id . "@" . $group_details->top_level_domain;

		// check user id in use sdc
		if(is_numeric($user_id)){
			$sdc = ShortDialCodeDao::get_sdc_by_dial_code($connection, $user_id, $subscriber_details ["group_id"]);
			$sdc_by_number = ShortDialCodeDao::get_sdc_by_number($connection, $user_id, $subscriber_details ["group_id"]);
			if ($sdc || $sdc_by_number){
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "User Id provided by user are invalid...User Id is the same value with short dial codes " . $user_id );
				}
				$response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_USER_ID_IS_IN_USE_BY_SHORT_DIAL_CODE;
				$response_array ["ERROR_MESSAGE"] = $user_id;
				return $response_array;
			}
        }

        //Check whether the user ID starts with an alphanumeric char
        if (!ValidationMethods::isFirstCharAlphanumeric($user_id)) {
            $response_array ["ERROR_CODE"] = ApiResponseConstant::USER_ID_STARTS_WITH_NON_ALPHANUMERIC_CHAR;
            return $response_array;
        }

        if (SubscriberDao::checkIfUserIDAlreadyExistsAsDestination($connection, $user_id, $group_details->group_id)) {
            return $this->_build_error_message(
                ApiResponseConstant::API_CONSUMER_SUBSCRIBER_ALREADY_EXIST_AS_DESTINATION,
                $user_id
            );
        }

        // Check for Product details are Empty
        if (!isset($subscriber_details['products_details']) ||  empty($subscriber_details['products_details'])) {
            return $this->_build_error_message(ApiResponseConstant::SKU_NOT_EXIST, '');
        }

        $subscriber_details["authentication_method"] = $subscriber_details["authentication_method"] ?? null;
		if(UtilityMethods::isEmpty($subscriber_details["authentication_method"])) {
			$subscriber_details["authentication_method"] = 'BASIC'; # Can be set as BASIC or SSO
		}
        $psxFacade = new PSXFacade();
        if (!empty($subscriber_details['public_charge_id'])) {
            $psxResult = $psxFacade->addPSXNumber($subscriber_details ["group_id"], $subscriber_details['public_charge_id'], false, false);
            if (isset($psxResult['ERROR_CODE'])) {
                return $psxResult;
            }
        }

		// check voip alias in use sdc
		if(isset($subscriber_details ["voip_alias"])){
			$sub_alias = array();
			$sub_alias = explode(" ", $subscriber_details ["voip_alias"]);
			foreach ($sub_alias as $alias){
				$sdc = ShortDialCodeDao::get_sdc_by_dial_code($connection, $alias, $subscriber_details ["group_id"]);
				$sdc_by_number = ShortDialCodeDao::get_sdc_by_number($connection, $alias, $subscriber_details ["group_id"]);
				if ($sdc || $sdc_by_number){
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "User Alias provided by user are invalid...User Alias is the same value with short dial codes " . $alias );
					}
					$response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_ALIAS_OF_SUBSCRIBER_IS_IN_USE_BY_SHORT_DIAL_CODE;
					$response_array ["ERROR_MESSAGE"] = $alias;
					return $response_array;
				}
			}
            // Check voip alias and voip numbers are same or not
            foreach ($subscriber_details['voip_numbers'] as $VoIP) {
                if (UtilityMethods::isEqual($VoIP, $subscriber_details['voip_alias'])) {
                    $response_array["ERROR_CODE"] = ApiResponseConstant::ALIAS_AND_USER_ID_MUST_BE_UNIQUE;
                    $response_array["ERROR_MESSAGE"] = "";
                    return $response_array;
                }
            }
		}

        // check voip number already in use
        if (UtilityMethods::isNotEmpty($subscriber_details['voip_numbers'])) {
            foreach ($subscriber_details['voip_numbers'] as $voip) {
                $checkVoipNumber = PstndidDao::isPstnInUse($connection, $voip);
                if (UtilityMethods::isEqual($checkVoipNumber, true)) {
                    return $this->_build_error_message(ApiResponseConstant::SUBSCRIBER_PSTN_DID_NUMBER_ALREADY_IN_USE, '');
                }
                //check voip numbers and user id are same or not
                if (UtilityMethods::isEqual($voip, $user_id)) {
                    return $this->_build_error_message(ApiResponseConstant::USER_ID_CAN_NOT_BE_SAME_WITH_VOIP_NUMBER, $voip);
                }

                if (
                    !preg_match('/^[0-9]+$/', $voip)
                    || strlen($voip) > SubscriberConstant::VoIP_NUMBER_MAX_LENGTH
                    || strlen($voip) < SubscriberConstant::VoIP_NUMBER_MIN_LENGTH
                ) {
                    return $this->_build_error_message(ApiResponseConstant::INVALID_VOIP_FORMAT, 'voip_numbers');
                }
            }
        }

		// ACL-15222 Etisalat Specific Fix
		$e_product_name = SubscriberConstant::CALL_PERMISSION_RESTRICTED_PRODUCT;
		$e_call_permisson = SubscriberConstant::CALL_PERMISSION_RESTRICTED_VALUE;
		if (in_array($e_product_name, $subscriber_details['products_details']) &&
			($subscriber_details['call_permission'] != $e_call_permisson || $subscriber_details['call_forward_permission'] != $e_call_permisson)) {
			$subscriber_details['call_permission'] = $e_call_permisson;
			$subscriber_details['call_forward_permission'] = $e_call_permisson;
		}

		if (!$this->isItOperation() && isset ( $subscriber_details ["products_details"] ) && is_array ( $subscriber_details ["products_details"] ) && count ( $subscriber_details ["products_details"] ) > 0) {
			$is_limited = PartnerDao::get_single_result_by_group_id ( $connection, "is_limited", $group_details->parent_group_id );
			if ($is_limited == "1") {
				$grandparent_id = GroupDao::get_grandparent_group_id ( $connection, $group_details->parent_group_id );
				$product_details = ProductDao::getSubscriberProductDetailsForSkus ( $connection, $subscriber_details ["products_details"], $grandparent_id, $group_details->parent_group_id );
			} else {
				$product_details = ProductDao::getSubscriberProductDetailsForSkus ( $connection, $subscriber_details ["products_details"], $group_details->parent_group_id, $group_details->group_id );
			}
			if ($product_details) {
				$subscriber_details ["sku"] = $product_details ["skus"];
				$subscriber_details ["product_ids"] = $product_details ["product_ids"];
				$subscriber_details ["service_set_value"] = $product_details ["service_set_values"];
				$subscriber_details ["menu"] = $product_details ["menu"];

				$this->_set_subscriber_type ( $subscriber_details );
			}
		}
		// check first name and last name of mida user duplicate
		if(UtilityMethods::is_mida_bundle ( $subscriber_details ["service_set_value"] )){
			if(!MidaUserDao::is_mida_valid_name_for_add($connection, $subscriber_details['first_name'], $subscriber_details['last_name'], $subscriber_details ["group_id"])){
				$response_array ["ERROR_CODE"] = ApiResponseConstant::MIDA_NAME_NOT_VALID;
				$response_array ["ERROR_MESSAGE"] = $user_id;
				return $response_array;
			}
		}

        if ((UtilityMethods::is_rich_messaging_service_bundle($subscriber_details['service_set_value'])
            && strlen($subscriber_details['user_id']) > SubscriberConstant::MAX_LENGTH_FOR_SUB_WITH_RICH_MESSAGE_SKU)
        ) {
            return SubscriberValidator::build_error_message(
                ApiResponseConstant::SIP_USER_ID_LENGTH_LIMITED_FOR_RICH_MESSAGING_SKU_ADD, ''
            );
        }

		// Check the compatibility of mida production
		if(UtilityMethods::is_mida_bundle ( $subscriber_details ["service_set_value"] )){
			$valid_products_mida = UtilityMethods::valid_products_mida ( $subscriber_details ["service_set_value"] );
			if(!$valid_products_mida){
				return $this->_build_error_message ( ApiResponseConstant::INCOMPATABLE_PRODUCTS, "" );
			}
		}
        $ssoFacade = new SsoFacade();
        // authentication_method Checks Start
        // When SSO disabled and Authentication Method Blank
        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])
            && $group_details->is_sso_enabled) {
            $subscriber_details['authentication_method'] = SubscriberConstant::AUTHENTICATION_METHOD_BASIC;
        }
        // Default auth method is SSO when Only Single Sign On
        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])
            && UtilityMethods::isEqual($group_details->is_sso_enabled_subscriber,SsoConstant::MANDATORY_SSO_ENUM)) {
            $subscriber_details['authentication_method'] = SubscriberConstant::AUTHENTICATION_METHOD_SSO;
        }

        // Default auth method is BASIC when Only Username Password
        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])
            && UtilityMethods::isNotEqual($group_details->is_sso_enabled_subscriber,
                SsoConstant::MANDATORY_SSO_ENUM)) {
            $subscriber_details['authentication_method'] = SubscriberConstant::AUTHENTICATION_METHOD_BASIC;
        }
        $validationForAuthMethod = $ssoFacade->validateSubscriberAuthMethod(
            $subscriber_details['authentication_method'],
            $group_details->is_sso_enabled_subscriber,
            $subscriber_details['products_details']
        );
        if ($validationForAuthMethod['error']) {
            $response_array['ERROR_CODE'] = $validationForAuthMethod['error'];
            return $response_array;
        }
        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])) {
            $subscriber_details['authentication_method'] = '';
        }
        // authentication_method Checks End

        // authUserId Checks START
        $authUserIdValidation = [];
        if (isset($subscriber_details['sso_auth_user_id'])) {
            $subscriber_details['sso_auth_user_id'] = strtolower($subscriber_details['sso_auth_user_id']);
            $authUserIdValidation = $ssoFacade->validateSubscriberAuthUserId($group_details->group_id,
                $subscriber_details['sso_auth_user_id'],
                $subscriber_details['user_id'],
                $subscriber_details['products_details'],
                $subscriber_details['authentication_method']);
            if ($authUserIdValidation['error']) {
                $response_array['ERROR_CODE'] = $authUserIdValidation['error'];
                return $response_array;
            }
        } elseif (UtilityMethods::isNotEqual($subscriber_details['authentication_method'],
            SubscriberConstant::AUTHENTICATION_METHOD_BASIC)) {
            $response_array['ERROR_CODE'] = ApiResponseConstant::CANNOT_EMPTY_AUTH_USER_ID;
            return $response_array;
        }

        if (!isset($authUserIdValidation['sso_enabled']) || !$authUserIdValidation['sso_enabled']) {
            $subscriber_details['sso_auth_user_id'] = null;
        }
        // authUserId Checks END

        //check if there is more than one user password for KBS-API-001 subs
        $VoIPNumbersCount = count($subscriber_details['voip_numbers']);
        $serviceSetValues = $subscriber_details["service_set_value"];
        if (
            (!UtilityMethods::is_kbs_api_consumer_service_bundle($serviceSetValues) && !UtilityMethods::isKbsApiCallMeServiceBundle($serviceSetValues))
            && (UtilityMethods::is_api_consumer_service_bundle($serviceSetValues) || UtilityMethods::isKbsApiCallMePSTNServiceBundle($serviceSetValues) || UtilityMethods::is_api_callme_service_bundle($serviceSetValues))
        ) {
            if ($VoIPNumbersCount > 1) {
                $this->_error("Only 1 VoIP number is allowed to be assigned to subscriber.");
                return SubscriberValidator::build_error_message(ApiResponseConstant::SUBSCRIBER_UNABLE_TO_SAVE_ONLY_ONE_VOIP_NUMBER, "voip_numbers");
            }
            if ($VoIPNumbersCount == 0) {
                $this->_error("VoIP numbers cannot be empty.");
                return SubscriberValidator::build_error_message(ApiResponseConstant::VOIP_EMPTY, "voip_numbers");
            }
        }
        if (UtilityMethods::isMsTeamsServiceBundle($subscriber_details['service_set_value'])) {
            if (empty($subscriber_details['ms_teams_carrier_name'])) {
                $subscriber_details['ms_teams_carrier_name'] = MsTeamsCarrierDao::getDefaultCarrierName($connection, $group_details->group_id);
            }
            $validatorResponse = SubscriberValidator::preProcessMsTeamsDetails($connection, $subscriber_details, $group_details, null);
            if (is_array($validatorResponse)) {
                return $validatorResponse;
            }
        }

        // validate product and inventory exist
		$response_array = $this->_validateProductAndInventory ( $connection, $subscriber_details ["products_details"], $group_details, NULL );
		if (is_array ( $response_array ) && array_key_exists ( "ERROR_CODE", $response_array )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Products provided by user are invalid...(" . $response_array ["ERROR_CODE"] . ") - " . $user_id );
			}
			return $response_array;
		}
		$errror = SubscriberValidator::validate_subscriber_details(
            $connection,
            $param_array,
            CommonConstant::ACTION_TYPE_ADD,
            $subscriber_details,
            null,
            false,
            $this->fromMigration
        );
			if (UtilityMethods::check_validation_error_exist ( $errror )) {
				return $errror;
			}
		if ($product_details === false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Products provided by user are invalid..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS;
			$response_array ["ERROR_MESSAGE"] = "products_details";
			return $response_array;
		}
		unset ( $subscriber_details ["products_details"] );

		if (isset ( $subscriber_details ["provisioning_system"] )) {
			if ($group_details->allow_multiple_prov_system) {
				$provision_system_id = ProvisionSystemDao::get_system_id_by_system_name ( $connection, $group_details->group_identifier, $subscriber_details ["provisioning_system"] );
				if (UtilityMethods::isEmpty ( $provision_system_id )) {
					return $this->_build_error_message ( ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS, "provisioning_system" );
				}
				$subscriber_details ["provisioning_system"] = $provision_system_id;
			} else {
				unset ( $subscriber_details ["provisioning_system"] );
			}
		} // End of if(isset($subscriber_details["provisioning_system"]))

		if (isset ( $subscriber_details ["provisioning_system"] )) {
			$subscriber_details ["prov_system_id"] = $subscriber_details ["provisioning_system"];
		} else {
			$subscriber_details ["prov_system_id"] = $this->get_provisioning_system_id ( $connection, $group_details->group_id );
		}

		$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $subscriber_details ["site_identifier"] );

        if (ProvUtility::isSubscriberConfigured($subscriber_details ["subscriber_type"])) {
            $subscriber_details['is_default_subdomain_subscriber'] = 0;
            if ($site_service_information['is_default_subdomains_enabled']) {
                $subscriber_details['is_default_subdomain_subscriber'] = 1;
                $site_service_information['megaDomainPath'] = CommonConstant::DEFAULT_MODE_SITE_NAME . "."
                    . CommonConstant::DEFAULT_MODE_SMB_NAME . "." . $group_details->top_level_domain;
                $subscriber_details['sitePublicNumber'] = $site_service_information['public_number'];
            }
        }

        if ($site_service_information === false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Site Identifier provided by user is invalid..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::SITE_IDENTIFIER_NOT_EXIST;
			return $response_array;
		}
		$subscriber_details ["site_id"] = $site_service_information ["site_id"];
        $subscriber_details ["site_alias_prefix"] = $site_service_information ["alias_prefix"];
		$subscriber_details ["default_status"] = $site_service_information ["default_status"];
		$subscriber_details ["site_type"] = $site_service_information["type"];
		$subscriber_details ["site_vm_switch"] = $site_service_information["vm_switch"];

		//check sum user alias and site alias
        if (isset($subscriber_details['voip_alias']) && !empty($subscriber_details['voip_alias'])) {
            $subAlias = explode(' ', $subscriber_details['voip_alias']);
            foreach ($subAlias as $alias) {
                if ((strlen($alias) + strlen($subscriber_details['site_alias_prefix'])) > SiteConstant::USER_ALIAS_AND_SITE_ALIAS_LIMIT) {
                    if ($this->_isErrorEnabled()) {
                        $this->_error('The sum of user alias and site alias can not be longer than 13 characters' . $subscriber_details['site_alias_prefix'] . ' ' . $alias);
                    }
                    return [
                        'ERROR_CODE' => ApiResponseConstant::SITE_AND_USER_ALIAS_LONGER_THAN_13_CHARACTERS,
                        'ERROR_MESSAGE' => $subscriber_details['site_alias_prefix'] . ' ' . $alias
                    ];
                }
            }
        }

        $AADirectorySyncValidationResponse = AADirectorySyncFacade::factory($connection)->validateSubscriberDetails($subscriber_details);
        if (array_key_exists('ERROR_CODE', $AADirectorySyncValidationResponse)) {
            return $AADirectorySyncValidationResponse;
        }

		if (UtilityMethods::isSiteTypeVMOverlay($subscriber_details ["site_type"])){
			/* need to be able to provision VM overlay subscribers  but this requires us to do special processing
			 * Block for now */
			return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_CREATION_IN_VMOVERLAY_SITE_NOT_ALLOWED, "" );
		}

		if (ProvUtility::isSubscriberSipTrunk ( $subscriber_details ["subscriber_type"] )) {
			if (UtilityMethods::isNotEqual ( $site_service_information ["type"], SiteConstant::SITE_TYPE_PBX )) {
				return $this->_build_error_message ( ApiResponseConstant::SIP_PBX_SUBSCRIBER_SHOULD_HAVE_CONNECTED_PBX_TYPE_SITE, "" );
			}
			$site_sip_trunk_details = SiteDao::get_pbx_details ( $connection, $site_service_information ["site_id"], TRUE );
			if (UtilityMethods::isEmpty ( $site_sip_trunk_details )) {
				return $this->_build_error_message ( ApiResponseConstant::SIP_PBX_SUBSCRIBER_SHOULD_HAVE_CONNECTED_PBX_TYPE_SITE, "" );
			}
			$site_service_information = array_merge ( $site_service_information, $site_sip_trunk_details );
		} else {
			if (UtilityMethods::isEqual ( $site_service_information ["type"], SiteConstant::SITE_TYPE_PBX )) {
				return $this->_build_error_message ( ApiResponseConstant::SIP_PBX_SITE_CANNOT_ASSIGNED_TO_NORMAL_SUBSCRIBER, "" );
			}
		}

		if ($this->is_duplicate_userid ( $connection, $subscriber_details ["user_id"], $subscriber_details ["domain"] ) ||
			$this->is_duplicate_subcriber_user_id_and_alias($subscriber_details ["group_id"], $subscriber_details ["user_id"], $subscriber_details ["domain"])) {
			$recommended_user_id = $this->recommend_user_id ( $connection, $subscriber_details ["user_id"], $subscriber_details ["domain"] );
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "User Id already exist..." . $user_id . ", recommended user id is:" . $recommended_user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::SUBSCRIBER_USER_ID_ALREADY_EXIST_ACROSS_PORTAL;
			$response_array ["suggested_user_id"] = $recommended_user_id;
			return $response_array;
		}

        if (isset($subscriber_details['voip_alias']) && !empty($subscriber_details['voip_alias'])) {
            $check = SubscriberDao::checkDuplicatedAlias(
                $connection,
                $subscriber_details['voip_alias'],
                $subscriber_details['user_id'],
                $subscriber_details['site_id'],
                $subscriber_details["group_id"]
            );

            if ($check !== false) {
                $this->_error("Voip alias " . $subscriber_details["voip_alias"] . " already exist...");
                $response_array ["ERROR_CODE"] = ApiResponseConstant::SUBSCRIBER_USER_ALIAS_ALREADY_EXIST;
                $response_array ["ERROR_MESSAGE"] = $subscriber_details["voip_alias"];
                return $response_array;
            }
        }

		$this->_verify_override_options ( $subscriber_details, $site_service_information );
		$subscriber_type = $subscriber_details ["subscriber_type"];
		$service_set_value = $subscriber_details ["service_set_value"];
		$menu = $subscriber_details ["menu"];

        //check is there any user password for KLS-017 subs
        if (UtilityMethods::isLiveSupportInboundVoiceServiceBundle($subscriber_details['service_set_value'])
            && UtilityMethods::isNotEmpty(
                $subscriber_details['user_password'])
        ) {
            return SubscriberValidator::build_error_message(
                ApiResponseConstant::UNABLE_TO_ADD_SUBSCRIBER_WITHOUT_PASSWORD, ''
            );
        }

		if (UtilityMethods::isEqual ( $subscriber_type, ProvisioningConstant::SUBSCRIBER_TYPE_NON_PROVISION )) {
			$subscriber_details ["user_password"] = null;
        } elseif (UtilityMethods::isEqual($subscriber_type, ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED)) {
            $VoIPResponse = SubscriberValidator::preProcessVoIPDetails(
                $connection,
                $subscriber_details,
                $group_details,
                $site_service_information,
                null);

            if (is_array($VoIPResponse) && array_key_exists('ERROR_CODE', $VoIPResponse)) {
                return $VoIPResponse;
            }
            if (
                $psxFacade->isPSXEnabled($group_details->group_id)
                && empty($subscriber_details['voip_numbers'])
                && empty($subscriber_details['public_charge_id'])
                && !empty($subscriber_details['menu'])
                && !UtilityMethods::is_standalone_voicemail_menu_bundle($subscriber_details['menu'])
            ) {
                return ['ERROR_CODE' => ApiResponseConstant::PSX_PUBLIC_CHARGE_ID_IS_REQUIRED];
            }
            if (
                !empty($subscriber_details['authorization_code'])
                && !CTBSDao::getAuthorizationCodesByGroupIdAndValue($connection, $group_details->group_id, $subscriber_details['authorization_code'])
            ) {
                return ['ERROR_CODE' => ApiResponseConstant::AUTHORIZATION_CODE_IS_NOT_RESERVED_FOR_CUSTOMER];
            }
            if (
                !empty($subscriber_details['scheduled_call_restriction'])
                && $subscriber_details['scheduled_call_restriction'] == CommonConstant::ENABLE
                && !UtilityMethods::is_premium_subscriber($service_set_value)
            ) {
                return ['ERROR_CODE' => ApiResponseConstant::INSUFFICIENT_INVENTORY];
            }
            if (
                !empty($subscriber_details['public_charge_id'])
                && $psxFacade->isPSXEnabled($group_details->group_id)
                && UtilityMethods::isNotEqual($subscriber_details['public_charge_id'][0], PSXConstant::E164_NUMBER_PREFIX)
            ) {
                $subscriber_details['public_charge_id'] = PSXConstant::E164_NUMBER_PREFIX . $subscriber_details['public_charge_id'];
            }

			$livesupport_response = SubscriberValidator::pre_process_livesupport_details ( $connection, $subscriber_details, $group_details, $site_service_information, null );
			if (is_array ( $livesupport_response )) {
				return $livesupport_response;
			}


			$client_response = SubscriberValidator::pre_process_client_details ( $connection, $subscriber_details, $group_details, $site_service_information, null );
			if (is_array ( $client_response )) {
				return $client_response;
			}

			if (UtilityMethods::is_meetme_menu_bundle ( $menu )) {
				$meetme_response = SubscriberValidator::pre_process_meetme_details ( $connection, $subscriber_details, $group_details, null );
				if (is_array ( $meetme_response )) {
					return $meetme_response;
				}
			} // end of if (SS is MeetMe)
			if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu )) {
                $smartoffice_response = SubscriberValidator::pre_process_smart_office_details ( $connection, $subscriber_details, $group_details, null, $this->fromMigration );
				if (is_array ( $smartoffice_response )) {
					return $smartoffice_response;
				}
			} // end of if (SS is SmatOffice Screen Share)
			if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
                $smartoffice_response = SubscriberValidator::pre_process_smart_office_details ( $connection, $subscriber_details, $group_details, null, $this->fromMigration);
				if (is_array ( $smartoffice_response )) {
					return $smartoffice_response;
				}
			} // end of if (SS is SmatOffice Video Share)
			if (UtilityMethods::is_ipscape_menu_bundle ( $menu )) {
				$ipscape_response = IpScapeValidator::pre_process_ipscape_details ( $connection, $group_details );
				if (is_array ( $ipscape_response )) {
					return $ipscape_response;
				}
			} // end of if (SS is ipSCAPE)
			if (UtilityMethods::is_mida_menu_bundle ( $menu )) {
				$mida_response = MidaValidator::pre_process_mida_details ( $connection, $group_details );
				if (is_array ( $mida_response )) {
					return $mida_response;
				}
			} // end of if (SS is Mida)
		}  // end of if (subscriber => Configured)
		else if (ProvUtility::isSubscriberSipTrunk ( $subscriber_type )) {
			if (UtilityMethods::is_sip_pbx_basic_menu_bundle ( $menu )) {
				$subscriber_details ["user_password"] = null;
			} elseif (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
				$provision_response = SubscriberValidator::pre_process_provision_details ( $connection, $subscriber_details, $group_details, null );
				if (is_array ( $provision_response )) {
					return $provision_response;
				}
			}
			$sip_trunk_response = SubscriberValidator::pre_process_sip_trunk_details ( $connection, $subscriber_details, $group_details, null );
			if (is_array ( $sip_trunk_response )) {
				return $sip_trunk_response;
			}
		}

        if (UtilityMethods::isSoForSfdcSubscriberBundle($service_set_value)) {
            $validate = SubscriberValidator::validateSfdc($subscriber_details, CommonConstant::ACTION_TYPE_EDIT);
            if (!empty($validate['validation_errors'])) {
                if (empty($subscriber_details['sfdc_email'])) {
                    $responseSfdc['ERROR_CODE'] = ApiResponseConstant::SFDC_MAIL_REQUIRED_CHECK;
                    return $responseSfdc;
                }
                $responseSfdc['ERROR_CODE'] = ApiResponseConstant::SFDC_MAIL_FORMAT_VALID;
                return $responseSfdc;
            } elseif (!UtilityMethods::is_VoIP_number_not_empty($subscriber_details['voip_numbers'])) {
                $responseVoip ['ERROR_CODE'] = ApiResponseConstant::VOIP_NUMBER_REQUIRED_FOR_SFDC_USER;
                return $responseVoip;
            }
        }

		if (UtilityMethods::isEqual ( $subscriber_type, ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED ) || UtilityMethods::isEqual ( $subscriber_type, ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED_STANDALONE )) {

			$provision_response = SubscriberValidator::pre_process_provision_details ( $connection, $subscriber_details, $group_details, null );
			if (is_array ( $provision_response )) {
				return $provision_response;
			}

			if (UtilityMethods::is_voicemail_menu_bundle($menu) && !$this->fromMigration) {
				$voicemail_response = SubscriberValidator::pre_process_voicemail_details ( $connection, $subscriber_details, $group_details, null );
				if (is_array ( $voicemail_response )) {
					return $voicemail_response;
				}
			} // end of if(voicemail SS)
		} // end of if (subscriber => configured OR Configured_Standalone)

		$call_executed_list = array();

		$individualProv = new models\external\prov\Individual ();

		if (UtilityMethods::is_voicemail_menu_bundle($menu) && !$this->fromMigration) {
			$subscriber_details ["voicemail_account"] = $this->_generate_voicemail_account ( $connection );
            if (UtilityMethods::is_rich_messaging_service_bundle($subscriber_details['service_set_value'])) {
                $modifyRichMessagingAccountServers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR ."|" .ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                $individualProv->modifyRichMessagingAccount($connection, $group_details, $subscriber_details, $modifyRichMessagingAccountServers);
            }
		} // end of if(SS is VM)

		if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu ) || UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
			$collab_type = ProvisioningConstant::SMART_OFFICE_VIDEO_COLLAB;
			if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu )) {
				$collab_type = ProvisioningConstant::SMART_OFFICE_WEB_COLLAB;
			}
			$smart_office_group_id = $this->_get_smart_office_group_id ( $group_details );
			$smart_office_proxy_id = $this->get_smart_office_proxy_detail ( $connection, $smart_office_group_id, $collab_type );
			$subscriber_details ["smart_office_proxy_id"] = $smart_office_proxy_id ["proxy_id"];
		}

		$group_domain = $this->_get_domain_name($group_details);

		// Check if this is a duplicate MSISDN if kandy_msisdn has been subscribed to.
		if (UtilityMethods::is_kandy_msisdn_bundle ( $service_set_value )) {
			$response = $this->check_kandy_msisdn_number ( $connection, $group_details, $subscriber_details );
			if (is_array ( $response ) && array_key_exists ( "ERROR_CODE", $response ))
				return $response;
			$subscriber_details ["mobile_country_code"] = $response [ProvisioningConstant::A2_RESPONSE]->countryCode;
			$this->_debug ( "mobile_country_code => " . print_r ( $subscriber_details ["mobile_country_code"], true ) );
		}

		if (isset ( $subscriber_details ['client_type'] )) {
			$subscriber_details ["client_type_id"] = ClientConfigurationDao::get_catalog_client_id_by_type ( $connection, $subscriber_details ['client_type'] ) ['client_type_id'];
		}
		try {
			/*
			 * Mark PSTN in progress & Commit and update A2 with new PSTN, so other are not using it
			 * Mark Devices in progress & Commit
			 */
			$this->_reserve_prov_in_progress_data_for_save ( $connection, $group_details, $subscriber_details );
		} catch ( Exception $reserve_exception ) {
			$response_array ["ERROR_CODE"] = ApiResponseConstant::UNABLE_TO_ADD_SUBSCRIBER;
			return $response_array;
		}

		try {
			$connection->beginTransaction ();

            if (
                $this->_is_field_not_empty($subscriber_details, "voip_numbers")
                && !UtilityMethods::is_standalone_voicemail_menu_bundle($menu)
            ) {
                $psxFacade = new PSXFacade();
                $psxFacade->validateNumbers($subscriber_details['voip_numbers'], $group_details->group_id);
            }

            // check sfdc subscriber sku
            if (UtilityMethods::isSoForSfdcSubscriberBundle($subscriber_details ["service_set_value"])) {
                $sfdcFacade = new SfdcFacade();
                $saveResponse = $sfdcFacade->saveSubscriber(
                    $connection,
                    $subscriber_details ["group_id"],
                    $subscriber_details['user_id'],
                    $subscriber_details['sfdc_email'],
                    $subscriber_details ['voip_numbers'],
                    $subscriber_details['voip_alias']
                );
                if (array_key_exists('ERROR_CODE', $saveResponse)) {
                    $this->_rollback_save_subscriber_details($connection, $group_details, $subscriber_details, $site_service_information, $call_executed_list);
                    DbConnector::rollbackTransaction($connection);
                    $this->_reset_prov_in_progress_reserved_data_for_save($connection, $group_details, $subscriber_details);
                    return $this->_build_error_message(
                        $saveResponse['ERROR_CODE'], $saveResponse['ERROR_MESSAGE']);
                }
                $call_executed_list[] = "saveSFDCSubscriber";
                $sfdcFacade->sendSfdcEmailNotification("Add", $group_details, $subscriber_details, "");
            }

            if (UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($service_set_value)) {
				if (array_key_exists('organizationalGroup', $subscriber_details)) {
                    $subscriber_details['callRecordingSettings']['organizationalGroupNames'] = implode('|', $subscriber_details['organizationalGroup']);
                }

                $addCallRecordingUser = $this->_add_call_recording_user($connection, $service_set_value, $subscriber_details, $call_executed_list);
                if (array_key_exists("ERROR_CODE", $addCallRecordingUser)) {
                    return $this->_build_error_message($addCallRecordingUser["ERROR_CODE"], "");
                }
            }

			if (ProvUtility::isVoicemailServiceNone ( UtilityMethods::getValueFromArray ( $subscriber_details, "voicemail_service", "" ) )) {
				if (UtilityMethods::isEqual ( $subscriber_type, ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED_STANDALONE )) {
					$subscriber_details ["voice_mail_directory_number"] = "";
				}
				$subscriber_details ["voicemail_server"] = "";
				$subscriber_details ["voicemail_number"] = "";
				$subscriber_details ["voicemail_pin"] = "";
				$subscriber_details ["voicemail_notification"] = ProvisioningConstant::VOICEMAIL_NOTIFICATION_OFF;
				$subscriber_details ["msg_ip_address"] = "";
			} elseif (ProvUtility::isVoicemailServicePermise ( UtilityMethods::getValueFromArray ( $subscriber_details, "voicemail_service", "" ) )) {
				$subscriber_details ["voicemail_pin"] = "";
				$subscriber_details ["voicemail_notification"] = ProvisioningConstant::VOICEMAIL_NOTIFICATION_OFF;
			}
			if (UtilityMethods::is_livesupport_service_bundle ( $service_set_value, false ) && !$this->fromMigration) {
				$livesupportfacade = new LiveSupportFacade();
				$ls_version = LiveSupportDao::get_company_details_by_group_id($connection, $group_details->group_id, "live_support_version");
				if (UtilityMethods::isEqual($ls_version, ProvisioningConstant::LIVE_SUPPORT_KBS_VERSION)) {

                    $spidrSubscriber = $this->getSpidrSubscriber(
                        $connection,
                        UtilityMethods::toObject($group_details),
                        $subscriber_details
                    );

                    //if subscriber does not exist on SPiDR, create subscriber
                    if (!$spidrSubscriber) {
                        $spidrResponse = $this->createSpidrSubscriber(
                            $connection,
                            UtilityMethods::toObject($group_details),
                            $subscriber_details,
                            $call_executed_list,
                            Spider::TYPE_NUVIA
                        );

                        if (!$spidrResponse) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error('Unable to create subscriber on SPiDR.');
                            }
                            $this->_check_translated_response('',
                                ApiResponseConstant::SUBSCRIBER_CREATE_SUBSCRIBER_ON_SPIDR
                            );
                        }
                    }

                    $call_executed_list[] = 'addSpidrSubscriber';
                    //if spidr account for subscriber was created previously update SPIDR account
                    if ($spidrSubscriber) {
                        $spidrAccountID = $user_id . '-' . $group_details->top_level_domain;
                        $spidrReqParams = [
                            'userID' => $subscriber_details['user_id'],
                            'userName' => $spidrAccountID,
                            'firstName' => $subscriber_details['first_name'],
                            'lastName' => $subscriber_details['last_name'],
                            'password' => $subscriber_details['user_password'],
                            'provSystem' => $subscriber_details['prov_system_id'],
                            'spider_name' => Spider::TYPE_NUVIA,
                            'spiderProducts' => ProvisioningConstant::SPIDR_PRODUCTS
                        ];
                        $spidrProv = new Spider();
                        $spidrResponse = $spidrProv->modifySubscriber($connection, $spidrReqParams);
                        if (UtilityMethods::isNotEqual(
                            $spidrResponse[ProvisioningConstant::A2_RESPONSE],
                            ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
                        ) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error('update_kandy_subscriber unable to update SPiDR user ' . $user_id
                                    . ' response is ' . $spidrResponse[ProvisioningConstant::A2_RESPONSE]);
                            }
                        }
                    }
					/*
					 * For ACL-7951 When subscriber VM system is IMM we should still be able to enable LS
					 * add a workaround if group device_type is IMM than create subscriber only in ls group
					 */
					//add subscriber on CIM
					$servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR . '|' . ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                    $group_details->cim_group_identifier = 'ls' . $group_details->group_identifier;
                    $cim_response = $individualProv->createRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
                    if (UtilityMethods::isNotEqual($cim_response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                        if ($this->_isErrorEnabled()) {
                            $this->_error('Unable to create subscriber on CIM.');
                        }
                        $this->_check_translated_response($cim_response, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED);
                    }
                    $call_executed_list[] = 'createRichMessagingAccount';
				}

				//Add livesupport agent
if (!SITE_LIVE_SUPPORT_DISABLED) {
				$agent_response = $livesupportfacade->create_agent($connection, $subscriber_details, $group_details);
				if (array_key_exists ( "ERROR_CODE", $agent_response )) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Unable to create agent on Live Support." );
					}

					$agent_response[ProvisioningConstant::TRANSLATED_ERROR_MESSAGE] = $agent_response['ERROR_MESSAGE'];
					$this->_check_translated_response ( $agent_response, $agent_response['ERROR_CODE'] );
				}
				$call_executed_list[] = "addLiveSupportAgent";
}


			}

            // If API-Consumer products are assigned to subscriber
            if ($this->_isApiConsumerOrApiCallMeServiceBundle($service_set_value)) {
                // Check the KBS_APICONSUMER service set is available on the product
                if (!UtilityMethods::is_kbs_api_consumer_service_bundle($service_set_value)
                    || (UtilityMethods::is_kbs_api_consumer_service_bundle($service_set_value)
                        && UtilityMethods::is_VoIP_number_not_empty($subscriber_details['voip_numbers']))) {

                    // Check the service set is KBS_APICALLME or KBS_APICALLME_PSTN
                    if (!UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($service_set_value)) {

                        $subscriberDetailsSMS = $subscriber_details;

                        $userID = $subscriber_details['user_id'];
                        $userIDPosition = strpos($userID, '@');
                        $subscriberDetailsSMS['voicemail_account'] = substr($userID, 0, $userIDPosition);

                        $servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR . '|'
                            . ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;

                        $CIMResponse = $individualProv->createSMSAccount(
                            $connection,
                            $group_details,
                            $subscriberDetailsSMS,
                            $servers);

                        if (UtilityMethods::isNotEqual(
                            $CIMResponse [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error('Unable to create subscriber on CIM.');
                            }
                            $this->_check_translated_response(
                                $CIMResponse,
                                ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED);
                        }

                        $call_executed_list[] = 'createSMSAccount';
                    } else {
                        // If the servis set is KBS_APICALLME or KBS_APICALLME_PSTN, then should check if there is an external provider
                        $extProviderList = $this->getListOfExternalProviders($connection, $group_details->group_id);
                        $kbsApiCallMeProvider = ExternalProviderConstant::EXTERNAL_PROVIDERS['KBS_API_CALLME_PROVIDER'];
                        if (UtilityMethods::isEmpty($extProviderList[$kbsApiCallMeProvider])) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error('There is no external provider.');
                            }
                            $this->_check_translated_response(
                                '',
                                ApiResponseConstant::UPDATE_SUBSCRIBER_CREATE_SUBSCRIBER_WITH_NO_EXTERNAL_PROVIDER_ON_SPIDR
                            );
                        }
                    }
                }

                $spidrResponse = $this->createSpidrSubscriber(
                    $connection,
                    UtilityMethods::toObject($group_details),
                    $subscriber_details,
                    $call_executed_list,
                    Spider::TYPE_ANON_CALLME
                );

                if (!$spidrResponse) {
                    if ($this->_isErrorEnabled()) {
                        $this->_error('Unable to create subscriber on SPiDR.');
                    }
                    $this->_check_translated_response('', ApiResponseConstant::SUBSCRIBER_CREATE_SUBSCRIBER_ON_SPIDR);
                }
            }

            if (UtilityMethods::isEmpty($subscriber_details['msg_ip_address'])
                && UtilityMethods::isNotEmpty($site_service_information['sesm_name'])) {
                $sesmProfile = SesmProfileDao::get_sesm_profile_details(
                    $connection,
                    $subscriber_details['prov_system_id'],
                    $site_service_information['sesm_name']);

                if (UtilityMethods::isNotEmpty($sesmProfile)) {
                    $subscriber_details['msg_ip_address'] = $sesmProfile['ip_address'];
                }
            }

			if (ProvUtility::isDefaultStatusActive ( $subscriber_details ["default_status"] )) {
				SubscriberDao::insert_subscriber_invoice_details ( $connection, $subscriber_details, ReportConstant::SUBSCRIBER_INVOICE_ADDED_STATUS, $group_domain, ProvUtility::getPstnDidGroupId ( $group_details ) );
			}

			// $subscriber_details["default_status"] = "ACTIVE";
			$subscriber_details ["trial_expiry_action"] = "NOTIFY";
			$subscriber_id = SubscriberDao::insert_subscriber ( $connection, $subscriber_details );

            if (isset($subscriber_details['email']) && $subscriber_details['email'] != '' &&
                isset($group_details->subscriber_welcome_notification) && $group_details->subscriber_welcome_notification) {
                $this->sendWelcomeEmailNotification($group_details, $subscriber_details);
            }

            if(isset($subscriber_details['is_eup_advanced_enabled'])){
                $subscriber_details['is_eup_advanced_enabled'] = ($subscriber_details['is_eup_advanced_enabled'] == 'enabled' ? 1 : 0);
            }else{
				$Site_service_details = SiteDao::get_site_service_detail_for_prov($connection, $subscriber_details['group_id'], $subscriber_details['site_identifier']);
				$subscriber_details['is_eup_advanced_enabled'] = $Site_service_details['is_eup_advanced_enabled'];
            }
            SubscriberDao::update_subscriber_eup_advanced_enabling($connection, $subscriber_details['is_eup_advanced_enabled'], $subscriber_id, $subscriber_details['group_id']);
			$subscriber_details ["subscriber_id"] = $subscriber_id;
			$this->_add_remove__subscriber_notices ( $connection, $group_details->group_id );

			if (UtilityMethods::is_contact_center_menu_bundle ( $subscriber_details ["menu"] ) && $group_details->number_display_option == 3 && isset ( $subscriber_details ['campaign_number'] ) && ! empty ( $subscriber_details ['campaign_number'] ) && UtilityMethods::isNotEqual ( $subscriber_details ['campaign_number'], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
				$response = $this->insert_contact_center_people_campaign_number ( $connection, $group_details, $subscriber_details );
				if (is_array ( $response ))
					return $response;
			}

            if($subscriber_details ["voicemail_emails"] == 'enabled' && isset($subscriber_details ["email"])) {
                $subscriber_details ["voicemail_notification"] = ProvisioningConstant::VOICEMAIL_NOTIFICATION_ALWAYS;
            }

			$individualProv = new models\external\prov\Individual ();
			if (ProvUtility::isSubscriberConfigured ( $subscriber_type )) {
				/*
				 * Perform all DB update before sending A2 Calls
				 */
                if ($this->_is_field_not_empty($subscriber_details, "voip_numbers")) {
                    PstndidDao::update_pstndid_for_new_subscriber($connection, $subscriber_details, $group_details); // PSTN Update
                    pstndiddao::set_primary_pstn_did_for_individualprov($connection, $subscriber_details ["voice_mail_directory_number"]); // Set Primary PSTN
                }
				if (isset ($subscriber_details ["devices"]) && count ($subscriber_details ["devices"]) && !$this->isItOperation()) {
					$devices_valid = TerminalsDao::check_devices_available_for_group($connection, $subscriber_details["devices"],$group_details->group_id);
					$generic_devices_valid = GenericDeviceDao::check_generic_devices_available_for_group($connection, $subscriber_details["devices"], $group_details->group_id);
					$devices_valid = array_column($devices_valid, 'mac_address');
					$generic_devices_valid = array_column($generic_devices_valid, 'mac_address');
					if(count($devices_valid) > 0){
						TerminalsDao::assign_devices_for_subscriber($connection, $devices_valid, $group_details->group_id, $subscriber_id );
					}
					if(count($generic_devices_valid) > 0){
						GenericDeviceDao::assign_generic_devices_for_subscriber($connection, $generic_devices_valid, $group_details->group_id, $subscriber_id );
					}
				}
				/* Update Business Continuity Order Status Starts */
				if (UtilityMethods::is_bcpremium_bundle ( $service_set_value )) {
					$this->add_subscriber_business_continuity_status ( $connection, $group_details->group_id );
				}
				/* Update Business Continuity Order Status Ends */

                // Add Subscriber to A2 - Starts
                $response = $individualProv->addUser(
                    $connection,
                    $group_details,
                    $subscriber_details,
                    $site_service_information,
                    true
                );

				if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
                    $response_explode=explode(":",$response["A2_RESPONSE"]);
					if (strpos($response[ProvisioningConstant::A2_RESPONSE], ProvisioningConstant::PROVISIONING_SUCCESS_MSG) === false && strpos($response[ProvisioningConstant::A2_RESPONSE], 'Characters (",\) cannot be used') !== false){
						$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_VALIDATOR_FOR_SPECIAL_CHARACTER);
					}
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> save_subscriber_details failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					}
					if(empty($response["TRANSLATED_ERROR_MESSAGE"]) && UtilityMethods::isNotEmpty($response_explode[1])){
					    $response["TRANSLATED_ERROR_MESSAGE"]=$response_explode[1];
					}
					$this->_add_user_error_response($response);
					$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED );
				}
				$call_executed_list [] = "addUser";
				// Add Subscriber to A2 - Ends

				$this->_saveOrResetDevicePassword ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information, NULL );

                if ($this->_is_field_not_empty($subscriber_details, 'voip_numbers')) {
                    // VoIP Details
                    $this->_saveVoipDetails(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        $individualProv,
                        $call_executed_list,
                        $site_service_information
                    );
                }

				if ($this->_is_field_not_empty ( $subscriber_details, "call_permission" ) && $this->_is_field_not_empty ( $subscriber_details, "call_forward_permission" )) {
					$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}

				if ($this->_is_field_not_empty ( $subscriber_details, "location_name" )) {
					$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}

				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) || $this->_is_field_not_empty ( $subscriber_details, "public_charge_id" )) {
					$this->_setUserChargeInfo ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );

					if ($group_details->number_display_option != 1) {
						$this->_setDNandNQforUser1 ( $connection, $group_details, $subscriber_details, $site_service_information, $individualProv, $call_executed_list );
					}
				}

				$this->_updateUserAlias ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );

				if (
                    UtilityMethods::is_nonstandalone_voicemail_related_menu_bundle($menu)
                    && ProvUtility::isVoicemailServiceNotNone($subscriber_details ["voicemail_service"])
                    && !$this->fromMigration
                ) { // Voicemail Details
					$this->_saveVoicemailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}

				if (UtilityMethods::is_meetme_menu_bundle ( $menu )) { // Meetme Details
					$this->_saveMeetmeDetails ( $connection, $group_details, $subscriber_details, NULL, $individualProv, $call_executed_list );
				}

				if (UtilityMethods::is_callgrab_menu_bundle ( $menu )) { // Call Grabber
					$this->_saveCallgrabberDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}

				if (UtilityMethods::is_mobility_menu_bundle ( $menu )) { // MEP
					if (ProvUtility::isSubscriberMepExtensionEnabled ( $subscriber_details )) {
						$this->_enableMepExtensionDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					} // end of (MepExtension Enabled)
				}

				if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu ) || UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
					$this->_saveSmartOfficeDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, null, TRUE );
				}

				// set chosen profile or default mac_only profile if subscriber does not have MEP in service set
				$this->_saveMepDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );

                if (UtilityMethods::isNotEmpty($subscriber_details['sso_auth_user_id'])) {
                    // Check access for SSO
                    $ssoFacade = new SsoFacade();
                    $groupSsoAccessDetails = $ssoFacade->checkGroupSSOAccess($group_details->group_id,
                        SsoConstant::SUBSCRIBER_SSO);
                    if ($groupSsoAccessDetails['access']) {
                        // Create keycloak user
                        $createKeycloakUserResponse = $ssoFacade->createKeycloakUser($connection, $group_details,
                            $subscriber_details, SsoConstant::SUBSCRIBER_SSO);

                        if (UtilityMethods::isNotEmpty($createKeycloakUserResponse['ERROR_CODE'])) {
                            if ($this->_isDebugEnabled()) {
                                $this->_debug('Access IDP SSO Facade -> createKeycloakUser failed to ' .
                                    'create keycloak User. Response is ' . json_encode($createKeycloakUserResponse));
                            }
                            $this->_rollback_save_subscriber_details($connection, $group_details, $subscriber_details,
                                $site_service_information, $call_executed_list);
                            return $createKeycloakUserResponse;
                        }
                        $call_executed_list [] = "addKeycloakSubscriber";
                    }
                }

                # For the initReset true domains LS agents' password must be resetted via backend
                if (UtilityMethods::is_livesupport_service_bundle( $service_set_value )) {
                    $ls_version = LiveSupportDao::get_company_details_by_group_id($connection, $group_details->group_id, "live_support_version");
                    if (UtilityMethods::isEqual($ls_version, ProvisioningConstant::LIVE_SUPPORT_KBS_VERSION)) {
                        //Password policy retrieval
                        $domain = new models\external\prov\Domain();
                        $domainInfoA2 = $domain->get_root_domain($connection, [
                            'prov_system_id' => $subscriber_details['prov_system_id'],
                            'top_level_domain' => $group_details->top_level_domain,
                        ]);
                        if (UtilityMethods::isNotArray($domainInfoA2)) {
                            throw new Exception("Domain info retrieval from A2 failed.");
                        }
                        $passwordPolicyName = null;
                        if (isset($domainInfoA2['passwordPolicy']['name'])) {
                            $passwordPolicyName = $domainInfoA2['passwordPolicy']['name'];
                        }
                        if (UtilityMethods::isEmpty($passwordPolicyName)) {
                            throw new Exception("Password Policy Name could not be found.");
                        }
                        $passwordPolicy = $domain->get_password_policy($connection, [
                            'prov_system_id' => $subscriber_details['prov_system_id'],
                            'top_level_domain' => $group_details->top_level_domain,
                        ], $passwordPolicyName);
                        if (UtilityMethods::isNotArray($passwordPolicy)) {
                            throw new Exception("Failed to get Password Policy from A2.");
                        }

                        if ($passwordPolicy['initReset'] == 1 || $passwordPolicy['initReset'] == "true") {
                            if ($passwordPolicy['preventPreviousPassword'] == 0 || $passwordPolicy['preventPreviousPassword'] == "false") {
                                //update agent password on pa
                                $pa = new Pa();
                                $parameter = array("password" => UtilityMethods::sip_data_out($subscriber_details['password']));
                                $pa->changePassword($connection, $subscriber_details, $parameter);
                            } else {
                                // InitReset is true/1
                                // PreventPreviousPassword is true/1
                                // Works as designed. The subscriber must be reset his/her password for initial login
                                $this->_debug('The Subscribers password policy includes PreventPreviousPassword. Therefore,
                                    the password of the subscriber must be resetted by his/her. ' . json_encode($subscriber_details ["subscriber_id"]));
                            }
                        }
                    }
                }

                if ($this->_isApiConsumerOrApiCallMeServiceBundle($service_set_value)) {
                    //update subscriber password on pa
                    $pa = new Pa();
                    $parameter = array("password" => UtilityMethods::sip_data_out($subscriber_details['password']));
                    $pa->changePassword($connection, $subscriber_details, $parameter);
                }

				if (UtilityMethods::is_omniclient_service_bundle ( $service_set_value )) {
                    // Retrieve subscriber on SPiDR
                    $spidrSubscriber = $this->getSpidrSubscriber(
                        $connection,
                        UtilityMethods::toObject($group_details),
                        $subscriber_details
                    );

                    // If subscriber does not exist on SPiDR, create subscriber
                    if (!$spidrSubscriber) {
                        $spidrResponse = $this->createSpidrSubscriber(
                            $connection,
                            UtilityMethods::toObject($group_details),
                            $subscriber_details,
                            $call_executed_list,
                            Spider::TYPE_NUVIA
                        );

                        if (!$spidrResponse) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error('Unable to create subscriber on SPiDR.');
                            }
                            $this->_check_translated_response(
                                '',
                                ApiResponseConstant::SUBSCRIBER_CREATE_SUBSCRIBER_ON_SPIDR
                            );
                        }
                    }

					$call_executed_list[] = "addSpidrSubscriber";
				} // end of omniclient_service_bundle

                if (
                    UtilityMethods::is_rich_messaging_service_bundle($service_set_value)
                    && (
                        ($this->fromMigration && $this->isDomainChanged)
                        || !$this->fromMigration
                    )
                ) {
                    $servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR ."|" .ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                    $group_details->cim_group_identifier = $group_details->group_identifier;

                    $cim_response = $individualProv->createRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
                    if (preg_match('/Invalid group/i', $cim_response[ProvisioningConstant::A2_RESPONSE])) {
                        $response = $this->createMissingCIMGroupAndMember($connection, $group_details, $subscriber_details, $servers);
                        if (array_key_exists('ERROR_CODE', $response)) {
                            $this->_check_translated_response($response['ERROR_MESSAGE'], $response['ERROR_CODE']);
                        }
                    } elseif (UtilityMethods::isNotEqual($cim_response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                        $this->_error('Unable to create subscriber on CIM.');
                        $this->_check_translated_response($cim_response, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED);
                    }

                    $call_executed_list[] = "createRichMessagingAccount";
                }

                if (UtilityMethods::isIntercomServiceBundle($service_set_value)) {
                    $this->setIPLForIntercom($connection, $group_details->top_level_domain, $subscriber_details);
                }

				$unistim_provision_response = $this->_process_unistim_device_provisioning ( $connection, $subscriber_details, $group_details, TRUE, NULL );
				if (! $unistim_provision_response) {
					throw new RuntimeException ( "Unistim provisioning failed" );
				}

				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" )) {
					// Reset In progress to disable
					PstndidDao::reset_pstndid_for_provision_in_progress ( $connection, $subscriber_details ["voip_numbers"], ProvUtility::getPstnDidGroupId ( $group_details ) );
				}
			} else if (UtilityMethods::isEqual ( $subscriber_type, ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED_STANDALONE )) {
				if (ProvUtility::isVoicemailServiceHosted ( $subscriber_details ["voicemail_service"] )) {
					$this->_saveVoicemailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}

                if (UtilityMethods::isMsTeamsServiceBundle($subscriber_details['service_set_value'])) {
                    $provisioningMSTeamsSubscriber = new ProvisioningMSTeamsSubscriber($connection, $group_details, $subscriber_details);
                    $provisioningMSTeamsSubscriber->create();
                    if ($this->_is_field_not_empty($subscriber_details, "voip_numbers")) {
                        PstndidDao::update_pstndid_for_new_subscriber($connection, $subscriber_details, $group_details);
                        PstndidDao::set_primary_pstn_did_for_individualprov($connection, $subscriber_details["voip_numbers"][0]);
                    }
                }

			} else if (ProvUtility::isSubscriberSipTrunk ( $subscriber_type )) {
				/*
				 * Perform all DB update before sending A2 Calls
				 */
				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" )) {
					PstndidDao::update_pstndid_for_new_subscriber ( $connection, $subscriber_details, $group_details ); // PSTN Update
					pstndiddao::set_primary_pstn_did_for_individualprov ( $connection, $subscriber_details ["voice_mail_directory_number"] ); // Set Primary PSTN
				}

				if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
                    // Add Subscriber to A2 - Starts
                    $response = $individualProv->addUser(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        $site_service_information,
                        true
                    );

					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> save_subscriber_details failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}
						$this->_add_user_error_response($response);
						$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED );
					}
					$call_executed_list [] = "addUser";
					// Add Subscriber to A2 - Ends

                    if (
                        $this->_is_field_not_empty($subscriber_details, "voip_numbers")
                        || $this->_is_field_not_empty($subscriber_details, "mobile_numbers")
                    ) {
						// Voip Details
						$this->_saveVoipDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information );
					}

					if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) && $this->_is_field_not_empty ( $subscriber_details, "call_permission" ) && $this->_is_field_not_empty ( $subscriber_details, "call_forward_permission" )) {
						$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}

					if ($this->_is_field_not_empty ( $subscriber_details, "location_name" )) {
						$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}

					if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) || $this->_is_field_not_empty ( $subscriber_details, "public_charge_id" )) {
						$this->_setUserChargeInfo ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );

						if ($group_details->number_display_option != 1) {
							$this->_setDNandNQforUser1 ( $connection, $group_details, $subscriber_details, $site_service_information, $individualProv, $call_executed_list );
						}
					}

				}

				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) && count ( $subscriber_details ["voip_numbers"] ) > 0) {
					$this->_associate_subscriber_to_pbx ( $connection, $subscriber_details, $group_details, $site_service_information, NULL, $call_executed_list );
				}

				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" )) {
					// Reset In progress to disable
					PstndidDao::reset_pstndid_for_provision_in_progress ( $connection, $subscriber_details ["voip_numbers"], ProvUtility::getPstnDidGroupId ( $group_details ) );
				}
			}
			$this->update_call_services ( $connection, UtilityMethods::toObject ( $subscriber_details ) );

			// Add a new Kandy subscriber.
			if (UtilityMethods::is_kandy_msisdn_bundle ( $subscriber_details ["service_set_value"] )) {
				if (! $this->_provision_kandy_subscriber ( $connection, $group_details, $subscriber_details, $response )) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Unable to provision Kandy user." );
					}
					$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MSISDN_ADD_SUBSCRIBER_FAILED );
				}
                $call_executed_list[] = 'addKandySubscriber';
			}

			// Add campaign_number to SBC if this is a Contact Center subscriber.
			if (UtilityMethods::is_contact_center_menu_bundle ( $subscriber_details ["menu"] ) && $group_details->number_display_option == 3) {
				if (! empty ( $subscriber_details ["campaign_number"] ) && UtilityMethods::isNotEqual ( $subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true ))
					$this->_add_campaign_number ( $connection, $subscriber_details ["campaign_number"], $subscriber_details, $call_executed_list );
			}

			$user_id = $subscriber_details ["user_id"];

			// set eup phone button configuration enabling

            $return_error = false;
            if (isset($subscriber_details ["allow_eup_config"]) && UtilityMethods::isNotEmpty($subscriber_details ["allow_eup_config"])){

                $eup_action_type = CommonConstant::ACTION_TYPE_EDIT;

                if ($isReset) {
                    $eup_action_type = CommonConstant::ACTION_TYPE_ADD;
                }

                $validate_enabling_allow_sub = DeviceButtonValidator::validate_enabling_allow_sub ($subscriber_details, $eup_action_type);
                if(array_key_exists("validation_errors", $validate_enabling_allow_sub)) {
                    $response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS;
                    $response_array ["ERROR_MESSAGE"] = key($validate_enabling_allow_sub['validation_errors']);
                    return $response_array;
                }
                $phonebutton_config_is_enabled = $this->is_phonebutton_config_enabled($subscriber_details ["group_id"], $subscriber_details ["user_id"]);
                if(array_key_exists("ERROR_CODE", $phonebutton_config_is_enabled)) {
                    return $phonebutton_config_is_enabled;
                }
                $subscriber_details ["allow_eup_config"] = ($subscriber_details ["allow_eup_config"] == 'enabled') ? '1':'0';
                if($phonebutton_config_is_enabled['is_phonebutton_enabled'] != '1') {
                    $subscriber_details['allow_eup_config'] = '0';
                }
                $eup_portal_phone_enable = SubscriberDao::set_eup_portal_phone_enabling($connection, $subscriber_details ["user_id"], $subscriber_details ["allow_eup_config"]);
                if (!$eup_portal_phone_enable){
                    $return_error = true;
                }
            } else{
                $default_allow_devicekeys_value = SiteDao::get_default_allow_eup_enabling($connection,$subscriber_details['site_identifier'], $subscriber_details ["group_id"])['is_phonebutton_enabled'];
                SubscriberDao::update_subscriber_phone_button_enabling($connection,$default_allow_devicekeys_value, $subscriber_details["subscriber_id"], $subscriber_details ["group_id"]);
            }
			if ($return_error){
			    if ($this->_isErrorEnabled ()) {
			        $this->_error ( "EUP portal phone button configuration enabling has failed " . $user_id );
			    }
			    DbConnector::rollbackTransaction($connection);
			    $response_array ["ERROR_CODE"] = ApiResponseConstant::SET_EUP_PORTAL_PHONEBUTTON_ENABLING_FAILED;
			    $response_array ["ERROR_MESSAGE"] = $user_id;
			    return $response_array;
			}

			// Presence should be enabled by default
			if(UtilityMethods::is_voicemail_service_bundle($subscriber_details ["service_set_value"])
				||UtilityMethods::is_voice_service_bundle($subscriber_details ["service_set_value"])){
                $connection = DbConnector::getConnection();
                $pa = new Pa();
				$presence_params = array();
		        $presence_params['on_the_phone_presence'] = CommonConstant::ENABLE;
		        $presence_params['report_when_inactive'] = CommonConstant::DISABLE;
		        $presence_params['inactivity_timer'] = 30;
		        $pa->setUserProfilePresence($connection, $subscriber_details, $presence_params);
				$response_param = $pa->setUserProfilePresence($connection, $subscriber_details, $presence_params);
				if($response_param[ProvisioningConstant::A2_RESPONSE] != CommonConstant::PROVISIONING_SUCCESS_MSG){
					$update_otp_required = SubscriberDao::update_otp_required($connection, $subscriber_details, true);
				}
            }

			// ACL 1388 Account Turn up Cache
			if (ProvUtility::isDefaultStatusActive ( $subscriber_details ["default_status"] )) {
				$sync_invoice_process = new SyncInvoiceProcessFacade ();
				$sync_invoice_process->invoke_sync_invoice_process ( $connection, SyncInvoiceConstant::SYNC_INVOICE_TASK_TYPE_CONTACT_CENTER, $group_details->group_id );
			}

			if ($subscriber_details ["default_status"] == 'TRIAL') {
				$this->activate_trial_subscriber ( $subscriber_details ["user_id"], $group_details, $connection, true );
			}

			// if this is a mida subscriber, we need to check for the appropriate setup SKUs to order sa well as send our trackit ticket to operations
            if (UtilityMethods::is_mida_menu_bundle ( $menu )) {
                $new_prod_id_list = explode(',', $subscriber_details["product_ids"]);
                $this->handle_new_mida_purchase($connection, $new_prod_id_list, $group_details, $subscriber_details);
            }

            $dashboard_degistration = new DashboardRegistrationFacade;
			$dashboard_degistration->get_device_registration_status_by_subscriber($subscriber_details ["user_id"]);

            //Create mida user
            $mida_tenant_id = MidaUserDao::get_tenant_id_by_group_id($connection, $group_details->group_id, 'tenant_id');
            $service_set_value = SubscriberDao::get_service_set_value($connection, $subscriber_details["user_id"], $subscriber_details["group_id"]);
			$services = preg_split("/\|/", $service_set_value);
            if(!empty($mida_tenant_id[0]['tenant_id'])){
            	if(in_array('mida_presence',$services) || in_array('mida',$services) || in_array('mida_sw',$services) || in_array('mida_op',$services)){
	            	$mida_facade = new MidaFacade;
	            	$user_id_without_domain = UtilityMethods::get_subscriber_id ( $subscriber_details ["user_id"] );
	            	$response = $mida_facade->create_mida_user($connection, $subscriber_details, $mida_tenant_id[0]['tenant_id'], $user_id_without_domain);
                    if ($response == ApiResponseConstant::ADD_MIDA_USER_FAILED) {
                        $this->delete_subscriber_details($subscriber_details['user_id'], $group_details);
                        $responseArray ["ERROR_CODE"] = ApiResponseConstant::UNABLE_TO_ADD_SUBSCRIBER;
                        $this->_error('Unable to create mida user with subscriber id ' . $subscriber_details["user_id"]);
                        return $responseArray;
                    } elseif ($response == ApiResponseConstant::ADD_MIDA_EXTENSION_FAILED) {
                        $this->delete_subscriber_details($subscriber_details['user_id'], $group_details);
                        $responseArray ["ERROR_CODE"] = ApiResponseConstant::ADD_MIDA_EXTENSION_FAILED;
                        $this->_error('Unable to create mida user with subscriber id ' . $subscriber_details["user_id"]);
                        return $responseArray;
                    }
            	}
            }

            // START - imm_ls - live support inbound voice provisioning.
            if (UtilityMethods::isLiveSupportInboundVoiceMenuBundle($menu)) {
				$this->runLiveSupportInboundVoiceProvisioning(
					$connection,
					$subscriber_details,
					$group_details,
					$call_executed_list
				);
            }
            // END - imm_ls - live support inbound voice provisioning.
            if(!DbConnector::inTransaction($connection)){
                $connection->beginTransaction();
            }

            if (
                $this->_is_field_not_empty($subscriber_details, "voip_numbers")
                && !UtilityMethods::is_standalone_voicemail_menu_bundle($menu)
            ) {
                // Provision voip numbers to psx
                $psxFacade = new PSXFacade();
                $psxFacade->addToPsx(
                    $subscriber_details['voip_numbers'],
                    $site_service_information['sesm_name'],
                    $group_details->group_id,
                    $connection
                );
            }

            AADirectorySyncFacade::factory($connection)->syncSubscriberDetails($subscriber_details);

            DbConnector::commitTransaction($connection);

			//for subscriber report
			$user_id = preg_split('/@/', $user_id)[0];
			$res_status = SubscriberDao::get_restricted_status($connection, $user_id);
			if ($res_status) {
				$subscriber_details['service_access_status'] = strtoupper(ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_DISPLAY_CONTENT_RESTRICTED);
			}

            // START - Report for Subscriber provisioning changes.
            $this->subscriber_historic_report(ReportConstants::EVENT_TYPE_ADD, $group_details, $subscriber_details);
            // END - Report for Subscriber provisioning changes.

            if (
                isset($subscriber_details['scheduled_call_restriction'])
                && CTBSDao::getCTBSProfileByGroup($connection, $group_details->group_id)
            ) {
                $authCodeForSubscriber = $subscriber_details['authorization_code'];
                $isAuthCodeParamEnabled = $subscriber_details['scheduled_call_restriction'] != CommonConstant::DISABLE;
                $ctbsFacade = new CTBSFacade();
                $ctbsCallTypes = $this->_generateCTBSArrayForSubscriber($subscriber_details['scheduled_call_restriction']);
                if ($isAuthCodeParamEnabled) {
                    $ctbsFacade->enableCTBSForSubscriber($subscriber_details['user_id'], $group_details->group_id, $ctbsCallTypes);
                    if (!empty($authCodeForSubscriber)) {
                        $ctbsFacade->setSubscriberAuthCode($subscriber_details['user_id'], $authCodeForSubscriber);
                        $this->_debug('Authorization code is assigned to ' . $authCodeForSubscriber);
                    }
                }
            }
        } catch ( Exception $e ) {
            /*
			 * On Failure to create subscriber, perform the following rollbacks
			 * 1. If user has call recording, delete the subscriber that was added in ORECX
			 * 3. Rollback user created in A2 before vacant update, so PSTN can be re-assigned to vacant users.
			 * 4. Cancel PSTN Did that was marked as in progress and update vacant pstn did in A2
			 */

			$this->_rollback_save_subscriber_details ( $connection, $group_details, $subscriber_details, $site_service_information, $call_executed_list );
            if(!DbConnector::inTransaction($connection)){
                $connection->beginTransaction();
            }
			DbConnector::rollbackTransaction ( $connection );

			$this->_reset_prov_in_progress_reserved_data_for_save ( $connection, $group_details, $subscriber_details );
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Creating Subscriber Failed!", $e );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::UNABLE_TO_ADD_SUBSCRIBER;
			if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
				return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
			}
			return $response_array;
		}
	}

	// end of method save_subscriber_details()

	/**
	 * <p>
	 * Inserts a new record into contact_center_people to record campaign_number.
	 * </p>
	 *
	 * @param unknown $subscriber_details
	 * @return NULL[]|number[]
	 */
	private function insert_contact_center_people_campaign_number($connection, $group_details, $subscriber_details) {
		$cc_parameters = array ();
		$cc_parameters ["sip_user_id"] = $subscriber_details ["user_id"];

		if (isset ( $subscriber_details ['campaign_number'] ) && ! empty ( $subscriber_details ['campaign_number'] ) && UtilityMethods::isNotEqual ( $subscriber_details ['campaign_number'], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
			$pstn_did_id = PstndidDao::get_pstn_id_for_pstn_number ( $connection, $group_details->pstn_group_id, $subscriber_details ['campaign_number'] );
			if (UtilityMethods::isEmpty ( $pstn_did_id )) {
				return array (
						'ERROR_CODE' => ApiResponseConstant::CONTACT_CENTER_PEOPLE_CAMPAIGN_NUMBER_NOT_EXIST,
						'ERROR_MESSAGE' => NULL
				);
			}
			$cc_parameters ['campaign_number'] = $pstn_did_id;
		} else {
			$cc_parameters ['campaign_number'] = NULL;
		}

		ContactCenterPeopleDao::save ( $connection, $group_details->group_id, $cc_parameters );
	}

	/**
	 * <p>
	 * Updates a contact_center_people with a new campaign_number.
	 * </p>
	 *
	 * @param unknown $subscriber_details
	 * @return NULL[]|number[]
	 */
	private function update_contact_center_people_campaign_number($connection, $group_details, $subscriber_details) {
		$cc_parameters = array ();
		$cc_parameters ["sip_user_id"] = $subscriber_details ["user_id"];

		if (isset ( $subscriber_details ['campaign_number'] ) && ! empty ( $subscriber_details ['campaign_number'] ) && UtilityMethods::isNotEqual ( $subscriber_details ['campaign_number'], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
			$pstn_did_id = PstndidDao::get_pstn_id_for_pstn_number ( $connection, $group_details->pstn_group_id, $subscriber_details ['campaign_number'] );
			if (UtilityMethods::isEmpty ( $pstn_did_id )) {
				return array (
						'ERROR_CODE' => ApiResponseConstant::CONTACT_CENTER_PEOPLE_CAMPAIGN_NUMBER_NOT_EXIST,
						'ERROR_MESSAGE' => NULL
				);
			}
			$cc_parameters ['campaign_number'] = $pstn_did_id;
		} else {
			$cc_parameters ['campaign_number'] = NULL;
		}

		ContactCenterPeopleDao::update_campaign_number ( $connection, $group_details->group_id, $cc_parameters );
	}

	private function _process_sip_dn_range($connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details, &$call_executed_list) {
		$sipTrunkProv = new models\external\prov\SipTrunk ();
		$add_dn_range_invoke = FALSE;
		if (! isset ( $subscriber_details ["voice_mail_directory_number"] )) {
			$subscriber_details ["voice_mail_directory_number"] = "";
			$subscriber_details ["start_range"] = "";
			$subscriber_details ["end_range"] = "";
		}
		if (UtilityMethods::isNotEmpty ( $old_subscriber_details ) && UtilityMethods::isNotEmpty ( $old_subscriber_details ["voip_numbers"] )) {
			if (UtilityMethods::isNotEqual ( $old_subscriber_details ["voip_numbers"] [0], $subscriber_details ["voice_mail_directory_number"] ) || UtilityMethods::isNotEqual ( $old_subscriber_details ["site_id"], @$subscriber_details ["site_id"] ) || UtilityMethods::isNotEqual ( $old_subscriber_details ["menu"], @$subscriber_details ["menu"] )) {
				$old_site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $old_subscriber_details ["site_identifier"] );
				$site_sip_trunk_details = SiteDao::get_pbx_details ( $connection, $old_site_service_information ["site_id"], TRUE );

				$dn_range_details = SitePbxDNRangeDao::get_dn_range ( $connection, $site_sip_trunk_details ["site_sip_trunk_id"], $old_subscriber_details ["voip_numbers"] [0], $group_details->group_id );
				SitePbxDNRangeDao::delete ( $connection, $dn_range_details ["site_pbx_dn_range_id"], $group_details->group_id );
				if (! isset ( $old_subscriber_details ["voice_mail_directory_number"] )) {
					$old_subscriber_details ["voice_mail_directory_number"] = $old_subscriber_details ["voip_numbers"] [0];
				}
				$old_site_service_information = array_merge ( $old_site_service_information, $site_sip_trunk_details, $dn_range_details, $old_subscriber_details );

				$response = $sipTrunkProv->deletePbxDNRange ( $connection, $old_site_service_information );
				if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> _process_sip_dn_range (deletePbxDNRange) failed  for user " . $old_subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					}
					$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_DELETE_PBX_DN_RANGE_CALL_FAILED );
				}
				$call_executed_list [] = "deletePbxDNRange";

				if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $old_subscriber_details ["menu"] ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $old_subscriber_details ["menu"] )) {
					$response = $sipTrunkProv->removeSubscriberFromPbx ( $connection, $old_subscriber_details, $site_service_information );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> _process_sip_dn_range (removeSubscriberFromPbx) failed  for user " . $old_subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}
						$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_LINK_SUBSCRIBER_TO_CALL_FAILED );
					}
					$call_executed_list [] = "removeSubscriberFromPbx";
				}

				if (UtilityMethods::isNotEmpty ( $subscriber_details ["voice_mail_directory_number"] )) {
					$add_dn_range_invoke = TRUE;
					$subscriber_details ["start_range"] = $subscriber_details ["voice_mail_directory_number"];
					$subscriber_details ["end_range"] = $subscriber_details ["voice_mail_directory_number"];
				}
			}
		} elseif (UtilityMethods::isNotEmpty ( $subscriber_details ["voice_mail_directory_number"] )) {
			$add_dn_range_invoke = TRUE;
			$subscriber_details ["start_range"] = $subscriber_details ["voice_mail_directory_number"];
			$subscriber_details ["end_range"] = $subscriber_details ["voice_mail_directory_number"];
		}

		if ($add_dn_range_invoke) {
			$dn_range_name = Dao::get_sequence_number ( CommonConstant::SITE_SIP_PBX_DN_NAME_SEQUENCE_KEY, 1 );
			$dn_range_name = ProvisioningConstant::SIP_PBX_DN_RANGE_NAME_PREFIX . $site_service_information ["end_point_identifier"] . "_" . sprintf ( '%1$04d', $dn_range_name );
			$root_dn_range_name = Dao::get_sequence_number ( CommonConstant::SITE_SIP_PBX_ROOT_DN_NAME_SEQUENCE_KEY, 1 );
			$root_dn_range_name = ProvisioningConstant::SIP_PBX_ROOT_DN_NAME_PREFIX . $site_service_information ["end_point_identifier"] . "_" . sprintf ( '%1$04d', $root_dn_range_name );

			$site_service_information ["name"] = $dn_range_name;
			$site_service_information ["root_dn_name"] = $root_dn_range_name;
			$site_service_information ["dn_range_start"] = $subscriber_details ["voice_mail_directory_number"];
			$site_service_information ["dn_range_end"] = $subscriber_details ["voice_mail_directory_number"];
			$site_service_information ["domain"] = $subscriber_details ["domain"];
			$site_service_information ["prov_system_id"] = $subscriber_details ["prov_system_id"];
			SitePbxDNRangeDao::insert ( $connection, $site_service_information );
			$response = $sipTrunkProv->addPbxDNRange ( $connection, $subscriber_details, $site_service_information );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _process_sip_dn_range (addPbxDNRange) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_ADD_PBX_DN_RANGE_CALL_FAILED );
			}
			$call_executed_list [] = "addPbxDNRange";

			if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $subscriber_details ["menu"] ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $subscriber_details ["menu"] )) {
				$subscriber_details ['pbx_user_ids'] = $this->get_associate_site_pbx_routing_subscribers ( $connection, $subscriber_details );
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> PBX Routing subscribers  associated with the site - " . $site_service_information ["site_identifier"] . " are " . $subscriber_details ['pbx_user_ids'] );
				}

				$response = $sipTrunkProv->linkSubscriberToPbx ( $connection, $subscriber_details, $site_service_information );
				if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> _process_sip_dn_range (linkSubscriberToPbx) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					}
					$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_LINK_SUBSCRIBER_TO_CALL_FAILED );
				}
				$call_executed_list [] = "linkSubscriberToPbx";
			}
		}
	}
	private function _associate_subscriber_to_pbx($connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details, &$call_executed_list) {
		$sipTrunkProv = new models\external\prov\SipTrunk ();

		PstndidDao::update_pstndid_for_new_subscriber( $connection, $subscriber_details, $group_details );

		if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $subscriber_details ["menu"] ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $subscriber_details ["menu"] )) {
			$subscriber_details ['pbx_user_ids'] = $this->get_associate_site_pbx_routing_subscribers ( $connection, $subscriber_details );
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> PBX Routing subscribers  associated with the site - " . $site_service_information ["site_identifier"] . " are " . $subscriber_details ['pbx_user_ids'] );
			}
			$response = $sipTrunkProv->linkSubscriberToPbx ( $connection, $subscriber_details, $site_service_information );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _process_sip_dn_range (linkSubscriberToPbx) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_LINK_SUBSCRIBER_TO_CALL_FAILED );
			}
			$call_executed_list [] = "linkSubscriberToPbx";
		}
	}

	public function get_associate_site_pbx_routing_subscribers($connection, $subscriber_details) {
		$user_details = SubscriberDao::get_associate_site_pbx_routing_subscribers ( $connection, $subscriber_details );
		$user_ids = "";
		if (is_array ( $user_details ) && count ( $user_details ) > 0) {
			return implode ( ",", $user_details );
		}
		return $user_ids;
	}

    /**
     * method to process [Add/Remove] unistim device
     *
     * @param $connection
     * @param array $subscriber_details
     * @param object $group_details
     * @param boolean $is_add_device
     * @param null|array $old_subscriber_devices
     * @return bool
     */
	private function _process_unistim_device_provisioning($connection, $subscriber_details, $group_details, $is_add_device, $old_subscriber_devices) {
		if ($this->isItOperation()) {
	        if ($this->_isDebugEnabled ()) {
                $this->_debug ( "IT OPERATIONS DOES NOT HAVE ACCESS" );
            }
            return false;
        }
		$success_provisioning_list = array ();
		$oldSubscriberDevicesCount = is_countable($old_subscriber_devices) ? count($old_subscriber_devices) : 0;
        if (!$this->isItOperation() && isset($subscriber_details["devices"]) && count($subscriber_details["devices"]) > 0 || $oldSubscriberDevicesCount > 0) {
			if (UtilityMethods::isNotEmpty ( $old_subscriber_devices )) {
				$devices_array = $old_subscriber_devices;
			} else {
				$devices_array = $subscriber_details ["devices"];
			}
			$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $subscriber_details ["site_identifier"] );
			$parameter_array = $this->_get_unistim_provision_parameter ( $subscriber_details, $group_details, $site_service_information );
			foreach ( $devices_array as $mac_address ) {
				$is_unistim_terminal = TerminalsDao::is_unistim_terminal ( $connection, $mac_address, $group_details->group_id );
				if ($is_unistim_terminal) {
					$parameter_array ["mac"] = $mac_address;
					if ($is_add_device) {
						$unistim_response = $this->add_unistim_device ( $connection, $parameter_array );
						if (UtilityMethods::isEqual ( $unistim_response ["STATUS"], CommonConstant::MESSAGE_TYPE_ERROR )) {
							$response = $this->_revert_unistim_provisioning ( $connection, $parameter_array, $success_provisioning_list );
							return false;
						} else {
							$success_provisioning_list [] = $mac_address;
							$parameter_array ["users"] = $subscriber_details ["user_id"];
							$unistim_response = $this->set_user_for_unistim_device ( $connection, $parameter_array );
							if (UtilityMethods::isEqual ( $unistim_response ["STATUS"], CommonConstant::MESSAGE_TYPE_ERROR )) {
								$response = $this->_revert_unistim_provisioning ( $connection, $parameter_array, $success_provisioning_list );
								return false;
							}
						}
					} else {
						$unistim_response = $this->remove_unistim_device ( $connection, $parameter_array );
						if (UtilityMethods::isEqual ( $unistim_response ["STATUS"], CommonConstant::MESSAGE_TYPE_ERROR )) {
							return false;
						}
					}
				}
			}
		}
		return true;
	}

	// method to remove unistim device to mac device
	private function _revert_unistim_provisioning($connection, $parameter_array, $success_provisioning_list) {
		if (count ( $success_provisioning_list ) > 0) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( 'SET USER FOR UNISTIM DEVICE FAILED. REVERT ADD UNISTIM DEVICE INITIATED' );
			}
			foreach ( $success_provisioning_list as $mac_address ) {
				$unistim_response = $this->remove_unistim_device ( $connection, $parameter_array );
				if (UtilityMethods::isEqual ( $unistim_response ["STATUS"], CommonConstant::MESSAGE_TYPE_ERROR )) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Revert remove unistim user for MAC failed.." . $mac_address );
					}
				} else {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Revert remove unistim user for MAC success.." . $mac_address );
					}
				}
			}
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( 'SET USER FOR UNISTIM DEVICE FAILED. REVERT ADD UNISTIM DEVICE FINISHED' );
			}
		}
	}

	// method to get unistim provisioning parameter
	private function _get_unistim_provision_parameter($subscriber_details, $group_details, $site_service_information) {
		$parameter_array = array ();
		$parameter_array ['provSystem'] = $subscriber_details ["prov_system_id"];
		$parameter_array ['domain'] = $site_service_information ["subdomain_name"];
		$parameter_array ['timezone'] = $subscriber_details ["timezone"];
		$parameter_array ['idleDisplay'] = $group_details->short_name;
		return $parameter_array;
	}
	private function _rollback_save_subscriber_details($connection, $group_details, $subscriber_details, $site_service_information, $call_executed_list) {
		if (count ( $call_executed_list ) > 0) {
			try {
				$individualProv = new models\external\prov\Individual ();
				$prov_system_id = $this->get_provisioning_system_id($connection, $group_details->group_id);

                if (in_array("addUser", $call_executed_list)) {
                    $this->_rollbackRemoveSubscriber($connection, $group_details, $subscriber_details, $individualProv, $call_executed_list);
                }

                if (in_array('_add_call_recording_user => addUser', $call_executed_list)) {
                    $this->_delete_call_recording_user(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        $call_executed_list
                    );
                    (in_array('_delete_call_recording_user => deleteUser', $call_executed_list))
                    ? $this->_debug('The rollback from Orecx is complete.')
                    : $this->_debug('The rollback from Orecx failed.');
                }

                if (in_array('saveSFDCSubscriber', $call_executed_list)) {
                    $sfdcFacade = new SfdcFacade();
                    $deleteResponse = $sfdcFacade->deleteSubscriber(
                        $connection,
                        $subscriber_details['user_id'],
                        $subscriber_details['sfdc_email'],
                        $subscriber_details ['voip_numbers'],
                        $subscriber_details['voip_alias']
                    );

                    if (array_key_exists('ERROR_CODE', $deleteResponse)) {
                        $this->_debug('The rollback from SalesForce failed.');
                    }
                    $this->_debug('The rollback from SalesForce is complete.');
                }

				if (in_array ( "addPbxDNRange", $call_executed_list )) {
					$sipTrunkProv = new models\external\prov\SipTrunk ();
					$site_sip_trunk_details = SiteDao::get_pbx_details ( $connection, $site_service_information ["site_id"], TRUE );
					$subscriber_details ["voice_mail_directory_number"] = $subscriber_details ["voip_numbers"] [0];
					$dn_range_details = SitePbxDNRangeDao::get_dn_range ( $connection, $site_sip_trunk_details ["site_sip_trunk_id"], $subscriber_details ["voip_numbers"] [0], $group_details->group_id );
					$site_sip_trunk_details = array_merge ( $dn_range_details, $site_sip_trunk_details, $subscriber_details );
					$response = $sipTrunkProv->deletePbxDNRange ( $connection, $subscriber_details, $site_sip_trunk_details );
					$this->_check_rollback_response ( $response, $subscriber_details, "deletePbxDNRange" );
				}

                if (in_array('addSpidrSubscriber', $call_executed_list)) {
                    $this->deleteSpidrSubscriber($connection, $group_details, $subscriber_details);
                }

				if (in_array ( "addGroupMember", $call_executed_list )) {
					$group_details->member_group_identifier = "ls" .$group_details->group_identifier;
					$individualProv->removeGroupMember($connection, $group_details, $subscriber_details);
				}

				if(in_array("createRichMessagingAccount", $call_executed_list)){

					$individualProv->deleterRichMessagingAccount($connection, $group_details, $subscriber_details);
				}

                if (in_array('createSMSAccount', $call_executed_list)) {
                    $subscriberDetailsSMS = $subscriber_details;

                    $userID = $subscriber_details['user_id'];
                    $userIDPosition = strpos($userID, '@');
                    $subscriberDetailsSMS['voicemail_account'] = substr($userID, 0, $userIDPosition);

                    $CIMResponse = $individualProv->deleteSMSAccount($connection, $group_details, $subscriberDetailsSMS);
                    $this->_check_rollback_response($CIMResponse, $subscriberDetailsSMS, 'deleteSMSAccount');
                }

				if (in_array("addLiveSupportAgent", $call_executed_list)) {
					$livesupportfacade = new LiveSupportFacade();
					$ls_subscriber_details = $subscriber_details;
					$ls_subscriber_details['user_id'] = substr($subscriber_details['user_id'], 0, strpos($subscriber_details['user_id'], "@"));
					$lsResponse = $livesupportfacade->delete_agent($ls_subscriber_details, $group_details);
				}

				if (in_array("addKandySubscriber", $call_executed_list)) {
					$kandy_response = $this->_delete_kandy_subscriber($connection, $group_details, $subscriber_details);
				}

                $realm_name = $group_details->top_level_domain;
                if (UtilityMethods::isSMB($group_details->group_type)
                    && UtilityMethods::isEqual($group_details->idp_inheritance, GroupConstant::IDP_INHERITANCE_DISABLED)) {
                    $realm_name = $group_details->smb_prefix . '.' . $group_details->top_level_domain;
                }

                $ssoFacade = new SsoFacade();
                if (in_array("addKeycloakSubscriber", $call_executed_list)) {
                    $ssoFacade->createKeycloakUser($connection, $group_details, $subscriber_details, SsoConstant::SUBSCRIBER_SSO);
                }

                if (array_key_exists('executedLsInboundVoiceSteps', $call_executed_list)) {
					$provLsInboundVoice = new ProvisioningLiveSupportInboundVoice(
						$connection,
						$subscriber_details,
						$group_details
					);
					$provLsInboundVoice->rollback($call_executed_list['executedLsInboundVoiceSteps']);
                }

			} catch ( Exception $rollback_exception ) {
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Unable to rollback created user" . $subscriber_details ["user_id"], $rollback_exception );
				}
			}
		}
	}

	// end of method _rollback_save_subscriber_details()
	private function _rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details) {
		if (count ( $call_executed_list ) > 0) {
			try {
				$individualProv = new models\external\prov\Individual ();
				$liveSupportFacade = new LiveSupportFacade();
                $prov_system_id = $this->get_provisioning_system_id($connection, $group_details->group_id);
                $tmpCallExecutedList = [];

				if (in_array ( "createVoicemail", $call_executed_list )) {
					$response = $individualProv->findAndDeleteVoicemail ( $connection, $group_details, $subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "findAndDeleteVoicemail" );
				}
				if (in_array ( "modifyVoicemail", $call_executed_list )) {
					if (isset ( $old_subscriber_details ["old_voip_numbers"] )) {
						$old_subscriber_details ["voip_numbers"] = $old_subscriber_details ["old_voip_numbers"];
					}
					$response = $individualProv->modifyVoicemail ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "modifyVoicemail" );

					if (in_array ( "SetPhoneSettings", $call_executed_list )) {
						$paProv = new models\external\prov\pa\Pa ();
						$response = $paProv->SetPhoneSettings ( $connection, $old_subscriber_details );
					}

					if (ProvUtility::isSubscriberConfigured ( $old_subscriber_details ["subscriber_type"] )) {
						$response = $individualProv->setUsersVoicemailServer ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setUsersVoicemailServer" );
					}
				}
				if (in_array ( "modifySMSAccount", $call_executed_list )) {
					$response = $individualProv->modifySMSAccount ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "modifySMSAccount" );
				}

                if (in_array('modifySpiderSubscriber', $call_executed_list)) {
                    $nuviaProvider = ExternalProviderConstant::EXTERNAL_PROVIDERS['NUVIA_PROVIDER'];
                    $callmeProvider = ExternalProviderConstant::EXTERNAL_PROVIDERS['CALLME_PROVIDER'];
                    $kbsApiCallMeProvider = ExternalProviderConstant::EXTERNAL_PROVIDERS['KBS_API_CALLME_PROVIDER'];
                    $nuviaSBCProvider = ExternalProviderConstant::EXTERNAL_PROVIDERS['NUVIA_SBC_PROVIDER'];

                    $extProviderList = $this->getListOfExternalProviders($connection, $group_details->group_id);

                    $userID = UtilityMethods::get_subscriber_id($subscriber_details['user_id']);
                    $spidrAccountID = $userID . '-' . $group_details->top_level_domain;
                    $extProviderID = $userID . '@' . $group_details->top_level_domain;
                    if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle(
                        $old_subscriber_details['service_set_value']
                    )) {
                        $destinationDigits = $old_subscriber_details['destination'];
                        $spidrAccountID = $destinationDigits . '-' . $group_details->top_level_domain;
                        $extProviderID = $destinationDigits . '@' . $group_details->top_level_domain;
                    }

                    $spidrProv = new Spider (Spider::TYPE_ANON_CALLME);
                    if (UtilityMethods::is_api_consumer_service_bundle($old_subscriber_details['service_set_value'])) {
                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_NO_CALLME;
                        $spidrProv->removeSpidrProduct(
                            $connection,
                            $spidrAccountID,
                            $subscriber_details['prov_system_id'],
                            ProvisioningConstant::INSTANT_MESSAGE
                        );

                        if (UtilityMethods::is_api_callme_service_bundle($subscriber_details['service_set_value'])) {
                            $extProvider = $extProviderList[$callmeProvider];
                        } elseif (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle(
                            $subscriber_details['service_set_value'])) {
                            $extProvider = $extProviderList[$kbsApiCallMeProvider];
                        } else {
                            $extProvider = $extProviderList[$nuviaProvider];
                        }

                        $spidrProv->removeSpidrProduct(
                            $connection,
                            $spidrAccountID,
                            $subscriber_details['prov_system_id'],
                            ProvisioningConstant::CALL_ME
                        );

                    } elseif (
                        UtilityMethods::is_api_callme_service_bundle($old_subscriber_details['service_set_value'])
                    ) {
                        $spidrProv->removeSpidrProduct(
                            $connection,
                            $spidrAccountID,
                            $subscriber_details['prov_system_id'],
                            ProvisioningConstant::INSTANT_MESSAGE
                        );

                        if (UtilityMethods::is_api_callme_service_bundle($subscriber_details['service_set_value'])) {
                            $extProvider = $extProviderList[$callmeProvider];
                            $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_CALLME;
                        } elseif (
                            UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle(
                                $subscriber_details['service_set_value']
                            )
                        ) {
                            $extProvider = $extProviderList[$kbsApiCallMeProvider];
                            $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_KBS_API_CALLME;
                        } else {
                            $extProvider = $extProviderList[$nuviaProvider];
                            $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS;
                        }

                    } elseif (
                        UtilityMethods::is_callrecording_service_bundle($subscriber_details['service_set_value'])
                    ) {
                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS;
                        $extProvider = $extProviderList[$nuviaSBCProvider];
                    } else {
                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS;
                        $extProvider = $extProviderList[$nuviaProvider];
                    }

                    $spidrReqParams = [
                        'userID' => $extProviderID,
                        'userName' => $spidrAccountID,
                        'firstName' => $subscriber_details['first_name'],
                        'lastName' => $subscriber_details['last_name'],
                        'password' => $subscriber_details['user_password'],
                        'provSystem' => $subscriber_details['prov_system_id'],
                        'spider_name' => $extProvider,
                        'spiderProducts' => $spidrProducts
                    ];

                    $spidrProv->modifySubscriber($connection, $spidrReqParams);
                }

                if (in_array('deleteSMSAccount', $call_executed_list)) {
                    $subscriberDetailsSMS = $subscriber_details;

                    $userID = $subscriber_details['user_id'];
                    $userIDPosition = strpos($userID, '@');
                    $subscriberDetailsSMS['voicemail_account'] = substr($userID, 0, $userIDPosition);

                    $servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR . '|'
                        . ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;

                    $CIMResponse = $individualProv->createSMSAccount(
                        $connection,
                        $group_details,
                        $subscriberDetailsSMS,
                        $servers);

                    $this->_check_rollback_response($CIMResponse, $subscriberDetailsSMS, 'deleteSMSAccount');

                }

                if (in_array('createSMSAccount', $call_executed_list)) {
                    $subscriberDetailsSMS = $subscriber_details;
                    $userID = $subscriber_details['user_id'];
                    $userIDPosition = strpos($userID, '@');
                    $subscriberDetailsSMS['voicemail_account'] = substr($userID, 0, $userIDPosition);

                    $CIMResponse = $individualProv->deleteSMSAccount($connection, $group_details, $subscriberDetailsSMS);
                    $this->_check_rollback_response($CIMResponse, $subscriberDetailsSMS, 'deleteSMSAccount');
                }

				if (in_array ( "findAndDeleteVoicemail", $call_executed_list )) {
					$response = $individualProv->createVoicemail ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "createVoicemail" );

					if (ProvUtility::isSubscriberConfigured ( $old_subscriber_details ["subscriber_type"] ) && (! UtilityMethods::is_non_standalone_auto_attendant_related_menu_bundle ( $subscriber_details ["menu"] ) || ProvUtility::isVoicemailServicePermise ( $subscriber_details ["voicemail_service"] ))) {
						$response = $individualProv->setUsersVoicemailServer ( $connection, $group_details, $subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setUsersVoicemailServer1" );
					}
				}

                // Rollback from Orecx when any errors.
                if (in_array('_add_call_recording_user => addUser', $call_executed_list)) {
                    $this->_delete_call_recording_user(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        $tmpCallExecutedList
                    );
                    (in_array('_delete_call_recording_user => deleteUser', $tmpCallExecutedList))
                        ? $this->_debug('The rollback from Orecx is complete.')
                        : $this->_debug('The rollback from Orecx failed.');
                }
                if (in_array('_update_call_recording_user => updateUser', $call_executed_list)) {
                    $this->_update_call_recording_user(
                        $connection,
                        $old_subscriber_details['service_set_value'],
                        $old_subscriber_details,
                        $tmpCallExecutedList
                    );
                    (in_array('_update_call_recording_user => updateUser', $tmpCallExecutedList))
                    ? $this->_debug('The rollback from Orecx is complete.')
                    : $this->_debug('The rollback from Orecx failed.');
                }
                if (in_array('_delete_call_recording_user => deleteUser', $call_executed_list)) {
                    $this->_add_call_recording_user(
                        $connection,
                        $old_subscriber_details['service_set_value'],
                        $old_subscriber_details,
                        $tmpCallExecutedList
                    );
                    (in_array('_add_call_recording_user => addUser', $tmpCallExecutedList))
                    ? $this->_debug('The rollback from Orecx is complete.')
                    : $this->_debug('The rollback from Orecx failed.');
                }

                if (in_array('updateSFDCSubscriber', $call_executed_list)) {
                    $sfdcFacade = new SfdcFacade();
                    $deleteResponse = $sfdcFacade->deleteSubscriber(
                        $connection,
                        $subscriber_details['user_id'],
                        $subscriber_details['sfdc_email'],
                        $subscriber_details ['voip_numbers'],
                        $subscriber_details['voip_alias']
                    );

                    if (array_key_exists('ERROR_CODE', $deleteResponse)) {
                        $this->_debug('The rollback from SalesForce failed.');
                    }
                    $this->_debug('The rollback from SalesForce is complete.');
                }

				if (in_array ( "addUser", $call_executed_list )) {
					$response = $individualProv->deleteUser ( $connection, $group_details, $subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "deleteUser" );
					/**
					 * If delete user called, then no need to check other executed calls.
					 */
					return;
				}
				if (in_array ( "changeUserPassword", $call_executed_list )) {
					$response = $individualProv->changePassword ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "changeUserPassword" );
				}
				$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $old_subscriber_details ["site_identifier"] );

				if (in_array ( "moveSingleUser", $call_executed_list )) {
					$response = $individualProv->modifyUserSubdomain ( $connection, $group_details, $old_subscriber_details, $site_service_information );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "moveSingleUser" );
				}
				if (in_array ( "setUserProfile_VideoCollabAdminService", $call_executed_list )) {
					$response = $individualProv->removeUserProfile_VideoCollabAdminService ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "removeUserProfile_VideoCollabAdminService" );
				}
				if (in_array ( "setUserProfile_WebCollabAdminService", $call_executed_list )) {
					$response = $individualProv->removeUserProfile_WebCollabAdminService ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "removeUserProfile_WebCollabAdminService" );
				}
				if (in_array ( "modifyUserServiceSets", $call_executed_list )) {
                    $response = $individualProv->modifyUserServiceSets(
                        $connection,
                        $group_details,
                        $old_subscriber_details,
                        $site_service_information,
                        $subscriber_details ['service_set_value'],
                        true
                    );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "modifyUserServiceSets" );
				}
				if (in_array ( "modifyUser", $call_executed_list )) {
                    $response = $individualProv->modifyUser(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        $site_service_information,
                        true
                    );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "modifyUser" );
				}
				if (in_array ( "setUserDirectoryNumber1", $call_executed_list )) {
					if (ProvUtility::isSubscriberMepExtensionEnabled ( $subscriber_details )) {
						$removeExtension_response = $individualProv->removeMobileExtensionUserData ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "removeMobileExtensionUserData" );
					}

					if ($group_details->number_display_option != 1) {
						$response = $individualProv->removeDNandNQforUser1 ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "removeDNandNQforUser1" );
					}

					$response = $individualProv->removeUserDirectoryNumber1 ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "removeUserDirectoryNumber1" );

                    if (count($old_subscriber_details ["voip_numbers"]) > 0 || ProvUtility::isSubscriberMepExtensionEnabled($old_subscriber_details)) {
                        $this->_reset_prov_in_progress_data_for_update($connection, $group_details, $subscriber_details, $old_subscriber_details);
                    }
					if (count ( $old_subscriber_details ["voip_numbers"] ) > 0 || ProvUtility::isSubscriberMepExtensionEnabled ( $old_subscriber_details )) {
						$response = $individualProv->setUserDirectoryNumber1 ( $connection, $group_details, $old_subscriber_details, true );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setUserDirectoryNumber1" );
					}

					if (in_array ( "setCosForUser1", $call_executed_list ) && count ( $old_subscriber_details ["voip_numbers"] ) > 0) {
						$response = $individualProv->setCosForUser1 ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setCosForUser1" );

						$response = $individualProv->setLocationForUser1 ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setLocationForUser1" );
					}
					if (in_array ( "removeCosForUser1", $call_executed_list )) {
						$response = $individualProv->setCosForUser1 ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setCosForUser1" );
					}
				}

				if (in_array ( "setUserChargeInfo1", $call_executed_list )) {
					$response = $individualProv->setUserChargeInfo1 ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "setUserChargeInfo1" );
				}

				if (in_array ( "removeUserChargeInfo1", $call_executed_list )) {
					$response = $individualProv->setUserChargeInfo1 ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "removeUserChargeInfo1" );
				}

				if (in_array ( "setDNandNQforUser1", $call_executed_list ) && count ( $old_subscriber_details ["voip_numbers"] ) > 0) {
					$response = $individualProv->setDNandNQforUser1 ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "setDNandNQforUser1" );
				}

				if (in_array ( "updateUserAlias", $call_executed_list )) {
					$response = $individualProv->updateUserAlias ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "updateUserAlias" );
				}

				if (in_array ( "enableMobileExtension", $call_executed_list )) {
					$response = $individualProv->disableMobileExtension ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "disableMobileExtension" );
				}

				if (in_array ( "modifyMobileExtensionUserData", $call_executed_list )) {
					$response = $individualProv->removeMobileExtensionUserData ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "removeMobileExtensionUserData" );

					$response = $individualProv->setUserDirectoryNumber1 ( $connection, $group_details, $old_subscriber_details, true );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "setUserDirectoryNumber1" );

					$response = $individualProv->modifyMobileExtension ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "modifyMobileExtensionUserData" );
				}

				if (in_array ( "disableMobileExtension", $call_executed_list )) {
					$response = $individualProv->enableMobileExtension ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "enableMobileExtension" );
				}

				if (in_array ( "setUserPMCData1", $call_executed_list ) || in_array ( "removeUserPMCData1", $call_executed_list )) {
					$old_state = ProvisioningConstant::DEVICE_PASSWORD_STATE_NONE;
					if (UtilityMethods::isNotEmpty ( $subscriber_details )) {
						$old_state = UtilityMethods::getValueFromArray ( $subscriber_details, "device_password_state" );
					}
					$new_state = UtilityMethods::getValueFromArray ( $old_subscriber_details, "device_password_state" );
					if (ProvUtility::isValidDevicePasswordStateNone ( $new_state ) && ProvUtility::isValidDevicePasswordStateNotNone ( $old_state )) {
						$response = $individualProv->removeDevicePassword ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "removeUserPMCData1" );
					} elseif (UtilityMethods::isNotEqual ( $old_state, $new_state ) || (ProvUtility::isValidDevicePasswordStateUser ( $new_state ) && ProvUtility::isValidDevicePasswordStateUser ( $old_state ) && UtilityMethods::isNotEqual ( $subscriber_details ["device_password"], $old_subscriber_details ["device_password"] ))) {
						// If device password is not empty then call setUserPMCData1
						$response = $individualProv->setDevicePassword ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setUserPMCData1" );
					}
				}

				if (in_array ( "setCallGrabDetails", $call_executed_list )) {
					if (UtilityMethods::isEmpty ( $old_subscriber_details ["callgrab_number"] )) {
						$old_subscriber_details ["callgrab_number"] = "";
					}
					$response = $individualProv->setCallGrabDetails ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "setCallGrabDetails" );
				}

				if (in_array ( "setMeetmeDetails", $call_executed_list )) {
					if (isset ( $old_subscriber_details ["meetme_access_code"] )) {
						$response = $individualProv->setMeetmeDetails ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setMeetmeDetails" );
					}
				}

				if (in_array ( "MEPsetUserAttribute", $call_executed_list )) {
					if (isset ( $old_subscriber_details ["meetme_access_code"] ) && ! empty ( $old_subscriber_details ["meetme_access_code"] )) {
						$response = $individualProv->MEPsetUserAttribute ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "MEPsetUserAttribute" );
					}
				}

				if (in_array ( "removeMeetMeDetails", $call_executed_list )) {
					if (isset ( $old_subscriber_details ["meetme_access_code"] )) {
						$response = $individualProv->setMeetmeDetails ( $connection, $group_details, $old_subscriber_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "removeMeetMeDetails" );
					}
				}

				if (in_array ( "saveMobilityService", $call_executed_list )) {
					$response = $individualProv->saveMobilityService ( $connection, $group_details, $old_subscriber_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "saveMobilityService" );
				}

				if (in_array ( "deletePbxDNRange", $call_executed_list ) || in_array ( "addPbxDNRange", $call_executed_list )) {
					$sipTrunkProv = new models\external\prov\SipTrunk ();

					if (in_array ( "deletePbxDNRange", $call_executed_list )) {
						$old_subscriber_details ["voice_mail_directory_number"] = $old_subscriber_details ["voip_numbers"] [0];
						$site_sip_trunk_details ["domain"] = $old_subscriber_details ["domain"];
						$site_sip_trunk_details ["prov_system_id"] = $old_subscriber_details ["prov_system_id"];
						$site_sip_trunk_details = SiteDao::get_pbx_details ( $connection, $site_service_information ["site_id"], TRUE );
						$dn_range_details = SitePbxDNRangeDao::get_dn_range ( $connection, $site_sip_trunk_details ["site_sip_trunk_id"], $old_subscriber_details ["voip_numbers"] [0], $group_details->group_id );
						$site_sip_trunk_details = array_merge ( $dn_range_details, $site_sip_trunk_details );
						$response = $sipTrunkProv->addPbxDNRange ( $connection, $site_sip_trunk_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "addPbxDNRange" );
					} else {
						$subscriber_details ["voice_mail_directory_number"] = $subscriber_details ["voip_numbers"] [0];
						$site_sip_trunk_details = SiteDao::get_pbx_details ( $connection, $site_service_information ["site_id"], TRUE );
						$dn_range_details = SitePbxDNRangeDao::get_dn_range ( $connection, $site_sip_trunk_details ["site_sip_trunk_id"], $subscriber_details ["voip_numbers"] [0], $group_details->group_id );
						$site_sip_trunk_details = array_merge ( $dn_range_details, $site_sip_trunk_details );
						$response = $sipTrunkProv->deletePbxDNRange ( $connection, $subscriber_details, $site_sip_trunk_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "deletePbxDNRange" );
					}
				}

				$smart_office_details = array ();
				if (UtilityMethods::is_smart_office_menu_bundle ( $old_subscriber_details ["menu"] )) {
					$smart_office_group_id = $this->_get_smart_office_group_id ( $group_details );
					$smart_office_details ["so_proxy_name"] = SmartOfficeProxyDao::get_so_proxy_name ( $connection, $old_subscriber_details ["smart_office_proxy_id"] );
					$smart_office_service_sets = ServiceSetDao::get_service_sets_by_menu_names ( $connection, array (
							ProvisioningConstant::menu_name_smart_office_video_collab,
							ProvisioningConstant::menu_name_smart_office_web_collab
					) );
					$service_set_array = explode ( "|", $old_subscriber_details ["service_set_value"] );
					$so_service_set = array_values ( array_intersect ( $service_set_array, $smart_office_service_sets ) );
					$smart_office_details ['so_group'] = SmartOfficeGroupDao::get_group_by_service_set_name ( $connection, $so_service_set [0] );
					$smart_office_details ['so_location'] = SMART_OFFICE_LOCATION;
				}

				if (in_array ( "modifyUserProfile_WebCollabAdminService", $call_executed_list )) {
					$response = $individualProv->modifyUserProfile_WebCollabAdminService ( $connection, $group_details, $old_subscriber_details, $smart_office_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "modifyUserProfile_WebCollabAdminService" );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG ) && is_string ( $response [ProvisioningConstant::A2_RESPONSE] ) && preg_match ( "/software error occurred/i", $response [ProvisioningConstant::A2_RESPONSE] )) {
						$response = $individualProv->setUserProfile_WebCollabAdminService ( $connection, $group_details, $old_subscriber_details, $smart_office_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setUserProfile_WebCollabAdminService" );
					}
				} else if (in_array ( "removeUserProfile_WebCollabAdminService", $call_executed_list )) {
					$response = $individualProv->setUserProfile_WebCollabAdminService ( $connection, $group_details, $old_subscriber_details, $smart_office_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "setUserProfile_WebCollabAdminService" );
				}

				if (in_array ( "modifyUserProfile_VideoCollabAdminService", $call_executed_list )) {
					$response = $individualProv->modifyUserProfile_VideoCollabAdminService ( $connection, $group_details, $old_subscriber_details, $smart_office_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "modifyUserProfile_VideoCollabAdminService" );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG ) && is_string ( $response [ProvisioningConstant::A2_RESPONSE] ) && preg_match ( "/software error occurred/i", $response [ProvisioningConstant::A2_RESPONSE] )) {
						$response = $individualProv->setUserProfile_VideoCollabAdminService ( $connection, $group_details, $old_subscriber_details, $smart_office_details );
						$this->_check_rollback_response ( $response, $old_subscriber_details, "setUserProfile_VideoCollabAdminService" );
					}
				} else if (in_array ( "removeUserProfile_VideoCollabAdminService", $call_executed_list )) {
					$response = $individualProv->setUserProfile_VideoCollabAdminService ( $connection, $group_details, $old_subscriber_details, $smart_office_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "setUserProfile_VideoCollabAdminService" );
				}

				if (in_array ( "addCampaignNumber", $call_executed_list )) {
					$campaignnumber_prov = new models\external\prov\CampaignNumber ();
					$people_details = SubscriberDao::get_subscriber_details_for_campaign_number ( $connection, $subscriber_details ['group_id'], $subscriber_details ['subscriber_id'] );
					$response = $campaignnumber_prov->removeCampaignNumber ( $connection, $people_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "addCampaignNumber" );
				}
				if (in_array ( "removeCampaignNumber", $call_executed_list )) {
					$campaignnumber_prov = new models\external\prov\CampaignNumber ();
					$people_details = SubscriberDao::get_subscriber_details_for_campaign_number ( $connection, $subscriber_details ['group_id'], $subscriber_details ['subscriber_id'] );
					$people_details ['campaign_number'] = ContactCenterPeopleDao::get_campaign_number_subscriber_id ( $connection, $subscriber_details ['group_id'], $subscriber_details ['subscriber_id'] );
					$response = $campaignnumber_prov->addCampaignNumber ( $connection, $people_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "removeCampaignNumber" );
				}
				if (in_array ( "modifyCampaignNumber", $call_executed_list )) {
					$campaignnumber_prov = new models\external\prov\CampaignNumber ();
					$people_details = SubscriberDao::get_subscriber_details_for_campaign_number ( $connection, $subscriber_details ['group_id'], $subscriber_details ['subscriber_id'] );
					$people_details ['campaign_number'] = ContactCenterPeopleDao::get_campaign_number_subscriber_id ( $connection, $subscriber_details ['group_id'], $subscriber_details ['subscriber_id'] );
					$response = $campaignnumber_prov->modifyCampaignNumber ( $connection, $people_details );
					$this->_check_rollback_response ( $response, $old_subscriber_details, "modifyCampaignNumber" );
				}

				if (in_array ( "createRichMessagingAccount", $call_executed_list )) {
					$cim_response = $individualProv->deleterRichMessagingAccount($connection, $group_details, $subscriber_details);
				}

				if (in_array("addGroupMember", $call_executed_list)) {
					$group_details->member_group_identifier = "ls" .$group_details->group_identifier;
					$individualProv->removeGroupMember($connection, $group_details, $subscriber_details);
				}

                if (in_array('addSpidrSubscriber', $call_executed_list)) {
                    $this->deleteSpidrSubscriber($connection, $group_details, $subscriber_details);
                }

				if (in_array("addLiveSupportAgent", $call_executed_list)) {
					$ls_subscriber_details = $subscriber_details;
					$ls_subscriber_details['user_id'] = substr($subscriber_details['user_id'], 0, strpos($subscriber_details['user_id'], "@"));
					$liveSupportFacade->delete_agent($ls_subscriber_details, $group_details);
				}
				if (in_array("deleteLiveSupportAgent", $call_executed_list)) {
					$liveSupportFacade->create_agent($connection, $old_subscriber_details, $group_details);
				}
				if (in_array("deleteGroupMember", $call_executed_list)) {
					$group_details->member_group_identifier = "ls" .$group_details->group_identifier;
					$individualProv->addGroupMember($connection, $group_details, $old_subscriber_details);
				}
				if (in_array("deleteRichMessagingAccount", $call_executed_list)) {
					$servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR ."|" .ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
					$group_details->cim_group_identifier = $group_details->group_identifier;
					$cim_response = $individualProv->createRichMessagingAccount($connection, $group_details, $old_subscriber_details, $servers);
				}

                if (in_array('deleteSpidrSubscriber', $call_executed_list)) {
                    $this->createSpidrSubscriber(
                        $connection,
                        $group_details,
                        $old_subscriber_details,
                        $call_executed_list,
                        Spider::TYPE_NUVIA
                    );
                }

                if (in_array('updateLiveSupportAgent', $call_executed_list)
                    || in_array('UpdateLiveSupportSubscriber', $call_executed_list)) {
					$liveSupportFacade->update_agent($old_subscriber_details, $group_details);
				}
				if (in_array("updateSpidrSubscriber", $call_executed_list)) {
					if ( UtilityMethods::isNotEqual ( $subscriber_details ["first_name"], $old_subscriber_details ["first_name"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["last_name"], $old_subscriber_details ["last_name"])
							|| UtilityMethods::isNotEqual ( $subscriber_details ["user_password"], $old_subscriber_details ["user_password"]) ||  UtilityMethods::isNotEqual ( $subscriber_details ["service_set_value"], $old_subscriber_details ["service_set_value"])) {

						$this->update_omni_subscriber($connection, $group_details, $old_subscriber_details);
					}
				}
				if (in_array("updateCIMSubscriber", $call_executed_list)) {
					$servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR ."|" .ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
					$group_details->cim_group_identifier = $group_details->group_identifier;
					$individualProv->modifyRichMessagingAccount($connection, $group_details, $old_subscriber_details, $servers);
				}
				if (in_array("addKandySubscriber", $call_executed_list)) {
					$this->_delete_kandy_subscriber($connection, $group_details, $subscriber_details);
				}
				if (in_array("deleteKandySubscriber", $call_executed_list)) {
					$this->_provision_kandy_subscriber($connection, $group_details, $old_subscriber_details, $response);
				}
				if (in_array("updateKandySubscriber", $call_executed_list)) {
					$this->update_kandy_subscriber($connection, $group_details, $old_subscriber_details);
				}
				if (in_array("modifyKandySubscriber", $call_executed_list)) {
					$this->modify_kandy_subscriber($connection, $group_details, $old_subscriber_details);
				}

                $realm_name = $group_details->top_level_domain;
                if (UtilityMethods::isSMB($group_details->group_type)
                    && UtilityMethods::isEqual($group_details->idp_inheritance, GroupConstant::IDP_INHERITANCE_DISABLED)) {
                    $realm_name = $group_details->smb_prefix . '.' . $group_details->top_level_domain;
                }

                $ssoFacade = new SsoFacade();
                if (in_array('deleteKeycloakSubscriber', $call_executed_list)) {
                    $ssoFacade->createKeycloakUser($connection, $group_details, $subscriber_details, SsoConstant::SUBSCRIBER_SSO);
                }
                if (in_array('addKeycloakSubscriber', $call_executed_list)) {
                    $ssoFacade->deleteKeycloakUser($connection, $group_details, $subscriber_details, SsoConstant::SUBSCRIBER_SSO);
                }
                if (in_array('updateKeycloakSubscriber', $call_executed_list)) {
                    $ssoFacade->updateKeycloakUser($connection, $group_details, $subscriber_details, $old_subscriber_details,
                        SsoConstant::SUBSCRIBER_SSO);
                }
            } catch (Exception $rollback_exception) {
                if ($this->_isErrorEnabled()) {
                    $this->_error('Unable to rollback updated user' . $subscriber_details ['user_id'], $rollback_exception);
                }
            }
        }
    }

	// end of method _rollback_update_subscriber_details()
	private function _check_rollback_response($response, $subscriber_details, $method_name) {
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( " Subscriber Facade ->Rollback _rollback_update_subscriber_details({$method_name}) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
		}
	}
	private function _reset_prov_in_progress_reserved_data_for_save($connection, $group_details, $subscriber_details) {
		if (ProvUtility::isSubscriberConfiguredOrSipTrunk ($subscriber_details['subscriber_type'])
			|| ProvUtility::isTypeStandaloneAndServiceSetImmLs($subscriber_details)
			|| ProvUtility::isTypeStandaloneAndServiceSetMsTeams($subscriber_details)) {
			try {
				$connection->beginTransaction ();
				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) && count ( $subscriber_details ["voip_numbers"] ) > 0) {
					PstndidDao::reset_pstndid_for_provision_in_progress ( $connection, $subscriber_details ["voip_numbers"], ProvUtility::getPstnDidGroupId ( $group_details ) );
					$pstn_did_vacant_userid_array = PstndidDao::get_unique_vacant_user_id_for_pstndid_numbers ( $connection, $subscriber_details ["voip_numbers"] );
                    if (VACANT_NUMBER_NEW_A2_SERVICE) {
                        $this->addDIDFromVacantList(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $subscriber_details ["voip_numbers"]
                        );
                    } else {
                        $this->updateVacentPstndidNumbers(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $pstn_did_vacant_userid_array
                        );
                    }
                }
				if (isset ( $subscriber_details ["devices"] ) && count ( $subscriber_details ["devices"] ) && !$this->isItOperation()) {
					TerminalsDao::reset_devices_reserved_for_prov ( $connection, $subscriber_details ["devices"], $group_details->group_id );
				}
				DbConnector::commitTransaction ( $connection );
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Unable to reset prov in progress reserved data for create!", $e );
				}
				throw $e;
			}
		}
	}
	private function _reserve_prov_in_progress_data_for_save($connection, $group_details, $subscriber_details) {
		if (ProvUtility::isSubscriberConfiguredOrSipTrunk ($subscriber_details['subscriber_type'])
			|| ProvUtility::isTypeStandaloneAndServiceSetImmLs($subscriber_details)
			|| ProvUtility::isTypeStandaloneAndServiceSetMsTeams($subscriber_details)) {
			try {
				$connection->beginTransaction ();

				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) && count ( $subscriber_details ["voip_numbers"] ) > 0) {
					PstndidDao::update_pstndid_for_provision_in_progress ( $connection, PstndidConstant::PSTN_DID_IN_PROGRESS_ENABLE, $subscriber_details ["voip_numbers"], ProvUtility::getPstnDidGroupId ( $group_details ), ($subscriber_details["subscriber_type"]==ProvisioningConstant::SUBSCRIBER_TYPE_SIP_TRUNK?PstndidConstant::PSTN_DID_PURPOSE_PBX_SITE:PstndidConstant::PSTN_DID_PURPOSE_NONE) );
					$pstn_did_vacant_userid_array = PstndidDao::get_unique_vacant_user_id_for_pstndid_numbers ( $connection, $subscriber_details ["voip_numbers"] );

                    // START- Voip numbers of inactive subscribers are added to chunks manually for inital save process
                    $voipNumbersForInialProcess = null;
                    if (UtilityMethods::isEqual(
                            $subscriber_details['default_status'],
                            SubscriberConstant::SUBSCRIBER_DEFAULT_STATUS_INACTIVE
                        )
                    ) {
                        $voipNumbersForInialProcess = $subscriber_details['voip_numbers'];
                    }
                    // END
                    if (VACANT_NUMBER_NEW_A2_SERVICE) {
                        $this->removeDIDFromVacantList(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $subscriber_details['voip_numbers'],
                            $voipNumbersForInialProcess
                        );
                    } else {
                        $this->updateVacentPstndidNumbers(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $pstn_did_vacant_userid_array,
                            $voipNumbersForInialProcess
                        );
                    }
                }

				if (isset ( $subscriber_details ["devices"] ) && count ( $subscriber_details ["devices"] ) > 0 && !$this->isItOperation()) {
					TerminalsDao::reserve_devices_for_prov ( $connection, $subscriber_details ["devices"], TerminalsConstant::PROV_IN_PROGRESS_READY, $group_details->group_id );
				}

				DbConnector::commitTransaction ( $connection );
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Unable to reserve prov in progress data during create subscriber!", $e );
				}
				throw $e;
			}
		} // end of if(suscriber = Configured)
	}

	// end of method _reserve_prov_in_progress_data()
	private function _reserve_prov_in_progress_data_for_update($connection, $group_details, $subscriber_details, $old_subscriber_details) {
		if (ProvUtility::isSubscriberConfiguredOrSipTrunk ( $subscriber_details ["subscriber_type"] )) {
			try {
                if(!DbConnector::inTransaction($connection)) {
                    $connection->beginTransaction();
                }
				$old_subscriber_voip_number = UtilityMethods::getValueFromArray ( $old_subscriber_details, "voip_numbers", array () );
				$new_subscriber_voip_number = UtilityMethods::getValueFromArray ( $subscriber_details, "voip_numbers", array () );

				$voip_numbers_diff = $this->_get_array_difference ( $old_subscriber_voip_number, $new_subscriber_voip_number, FALSE );
				$devices_diff = $this->_get_array_difference ( UtilityMethods::getValueFromArray ( $old_subscriber_details, "devices", array () ), UtilityMethods::getValueFromArray ( $subscriber_details, "devices", array () ), FALSE );
				if (count ( $voip_numbers_diff ["ADDED_ITEMS"] ) > 0) {
					PstndidDao::update_pstndid_for_provision_in_progress ( $connection, PstndidConstant::PSTN_DID_IN_PROGRESS_ENABLE, $voip_numbers_diff ["ADDED_ITEMS"], ProvUtility::getPstnDidGroupId ( $group_details ), ($subscriber_details["subscriber_type"]==ProvisioningConstant::SUBSCRIBER_TYPE_SIP_TRUNK?PstndidConstant::PSTN_DID_PURPOSE_PBX_SITE:PstndidConstant::PSTN_DID_PURPOSE_NONE) );
				}
				if (count ( $voip_numbers_diff ["REMOVED_ITEMS"] ) > 0) {
					PstndidDao::update_pstndid_for_provision_in_progress ( $connection, PstndidConstant::PSTN_DID_IN_PROGRESS_ENABLE, $voip_numbers_diff ["REMOVED_ITEMS"], ProvUtility::getPstnDidGroupId ( $group_details ), ($subscriber_details["subscriber_type"]==ProvisioningConstant::SUBSCRIBER_TYPE_SIP_TRUNK?PstndidConstant::PSTN_DID_PURPOSE_PBX_SITE:PstndidConstant::PSTN_DID_PURPOSE_SUBSCRIBER) );
				}
				if (count ( $voip_numbers_diff ["ADDED_ITEMS"] ) > 0 || count ( $voip_numbers_diff ["REMOVED_ITEMS"] ) > 0) {
					$pstn_array = $subscriber_details ["voip_numbers"];
					if (count ( $subscriber_details ["voip_numbers"] ) == 0) {
						$pstn_array = array_merge ( $voip_numbers_diff ["ADDED_ITEMS"], $voip_numbers_diff ["REMOVED_ITEMS"] );
					}
					$pstn_did_vacant_userid_array = PstndidDao::get_unique_vacant_user_id_for_pstndid_numbers ( $connection, $pstn_array );
                    if (VACANT_NUMBER_NEW_A2_SERVICE) {
                        $this->updateDIDFromVacantList(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $subscriber_details ["voip_numbers"],
                            $old_subscriber_details["voip_numbers"]
                        );
                    } else {
                        $this->updateVacentPstndidNumbers(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $pstn_did_vacant_userid_array
                        );
                    }
                }

				if (count ( $devices_diff ["ADDED_ITEMS"] ) > 0) {
					TerminalsDao::reserve_devices_for_prov ( $connection, $devices_diff ["ADDED_ITEMS"], TerminalsConstant::PROV_IN_PROGRESS_READY, $group_details->group_id );
				}
				if (count ( $devices_diff ["REMOVED_ITEMS"] ) > 0) {
					TerminalsDao::reserve_devices_for_prov ( $connection, $devices_diff ["REMOVED_ITEMS"], TerminalsConstant::PROV_IN_PROGRESS_READY, $group_details->group_id );
				}

				DbConnector::commitTransaction ( $connection );
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Unable to reserve prov in progress data during create subscriber!", $e );
				}
				throw $e;
			}
		} // end of if(suscriber = Configured)
	}

	// end of method _reserve_prov_in_progress_data()
	private function _reset_prov_in_progress_data_for_update($connection, $group_details, $subscriber_details, $old_subscriber_details) {
		if (ProvUtility::isSubscriberConfiguredOrSipTrunk ( $subscriber_details ["subscriber_type"] )) {
			try {
				$connection->beginTransaction ();

				$voip_numbers = $devices = array ();
				$old_subscriber_voip_number = UtilityMethods::getValueFromArray ( $old_subscriber_details, "voip_numbers", array () );
				$new_subscriber_voip_number = UtilityMethods::getValueFromArray ( $subscriber_details, "voip_numbers", array () );

				$old_subscriber_devices = UtilityMethods::getValueFromArray ( $old_subscriber_details, "devices", array () );
				$new_subscriber_devices = UtilityMethods::getValueFromArray ( $subscriber_details, "devices", array () );

				$voip_numbers_diff = $this->_get_array_difference ( $old_subscriber_voip_number, $new_subscriber_voip_number, FALSE );
				$devices_diff = $this->_get_array_difference ( $old_subscriber_devices, $new_subscriber_devices, FALSE );

				if (count ( $voip_numbers_diff ["ADDED_ITEMS"] ) > 0 || count ( $voip_numbers_diff ["REMOVED_ITEMS"] ) > 0) {
					$pstn_array = array_merge ( $voip_numbers_diff ["ADDED_ITEMS"], $voip_numbers_diff ["REMOVED_ITEMS"] );
					PstndidDao::reset_pstndid_for_provision_in_progress ( $connection, $pstn_array, ProvUtility::getPstnDidGroupId ( $group_details ) );
					if (count ( $subscriber_details ["voip_numbers"] ) > 0) {
						$pstn_array = $subscriber_details ["voip_numbers"];
					}
					$pstn_did_vacant_userid_array = PstndidDao::get_unique_vacant_user_id_for_pstndid_numbers ( $connection, $pstn_array );
                    if (VACANT_NUMBER_NEW_A2_SERVICE) {
                        $this->removeDIDFromVacantList(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $voip_numbers_diff["REMOVED_ITEMS"]
                        );

                        $this->addDIDFromVacantList(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $voip_numbers_diff["ADDED_ITEMS"]
                        );
                    } else {
                        $this->updateVacentPstndidNumbers(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $pstn_did_vacant_userid_array
                        );
                    }
				}

				if (count ( $devices_diff ["ADDED_ITEMS"] ) > 0) {
					$device_array = array_merge ( $devices_diff ["ADDED_ITEMS"], $devices_diff ["REMOVED_ITEMS"] );
					TerminalsDao::reset_devices_reserved_for_prov ( $connection, $device_array, $group_details->group_id );
				}
				DbConnector::commitTransaction ( $connection );
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Unable to reserve prov in progress data during create subscriber!", $e );
				}
				throw $e;
			}
		} // end of if(suscriber = Configured)
	}

	// end of method _reserve_prov_in_progress_data()
	private function _saveOrResetDevicePassword($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list, $site_service_information, $old_subscriber_details) {
		$old_state = ProvisioningConstant::DEVICE_PASSWORD_STATE_NONE;
		if (UtilityMethods::isNotEmpty ( $old_subscriber_details )) {
			$old_state = UtilityMethods::getValueFromArray ( $old_subscriber_details, "device_password_state" );
		}
		$new_state = UtilityMethods::getValueFromArray ( $subscriber_details, "device_password_state" );

		if (ProvUtility::isValidDevicePasswordStateNone ( $new_state ) && ProvUtility::isValidDevicePasswordStateNotNone ( $old_state )) {
			$response = $individualProv->removeDevicePassword ( $connection, $group_details, $subscriber_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( "Subscriber Facade -> Reset PMC failed for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_USER_PMC_DATA_CALL_FAILED );
			}
			$call_executed_list [] = "removeUserPMCData1";
		} elseif (UtilityMethods::isNotEqual ( $old_state, $new_state ) || UtilityMethods::isNotEqual ( $subscriber_details ["site_id"], $old_subscriber_details ["site_id"] ) || (ProvUtility::isValidDevicePasswordStateUser ( $new_state ) && ProvUtility::isValidDevicePasswordStateUser ( $old_state ) && isset ( $subscriber_details ["update_device_password_field"] ) && UtilityMethods::isNotEmpty ( $subscriber_details ["device_password"] ))) {
			// If device password is not empty then call setUserPMCData1
			if ($this->_is_field_not_empty ( $subscriber_details, "device_password_state" ) && $this->_is_field_not_empty ( $subscriber_details, "device_password" )) {
				$response = $individualProv->setDevicePassword ( $connection, $group_details, $subscriber_details );
				if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( "Subscriber Facade -> Save PMC failed for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					}
					if (preg_match('/Invalid character/i', $response[ProvisioningConstant::A2_RESPONSE])) {
						throw new CallFailedException( "", ApiResponseConstant::SET_USER_PMC_DATA_INVALID_CHARACTER);
					}
					$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_USER_PMC_DATA_CALL_FAILED );
				}
				$call_executed_list [] = "setUserPMCData1";
			}
		}
	}

    /**
     * Internal Method to save VoIP details
     *
     * @param object $connection
     * @param object $groupDetails
     * @param array $subscriberDetails
     * @param object $individualProv
     * @param array $callExecutedList
     * @param array $siteServiceInfo
     *
     * @return void
     */
    private function _saveVoipDetails(
        $connection,
        $groupDetails,
        $subscriberDetails,
        $individualProv,
        &$callExecutedList,
        $siteServiceInfo)
    {
        $this->_debug('# _saveVoipDetails');

        $userID = $subscriberDetails['user_id'];

        if ($groupDetails->number_display_option != 1
            || (
                $siteServiceInfo['is_default_subdomains_enabled']
                && $subscriberDetails['is_default_subdomain_subscriber']
                && UtilityMethods::isNotEmpty($siteServiceInfo['public_number']))
        ) {
            $response = $individualProv->removeDNandNQforUser1($connection, $groupDetails, $subscriberDetails);
            if (UtilityMethods::isNotEqual(
                $response[ProvisioningConstant::A2_RESPONSE],
                ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
            ) {

                if ($this->_isDebugEnabled()) {
                    $this->_debug('removeDNandNQforUser1 is failed for user '
                        . $userID . ' response is ' . $response[ProvisioningConstant::A2_RESPONSE]);
                }

                $this->_check_translated_response(
                    $response,
                    ApiResponseConstant::SUBSCRIBER_REMOVE_DN_AND_NQ_USER_CALL_FAILED);
            }
            $callExecutedList[] = 'removeDNandNQforUser1';
        }

        $removeDirectoryNumberResponse = $individualProv->removeUserDirectoryNumber1(
            $connection,
            $groupDetails,
            $subscriberDetails);

        if (UtilityMethods::isNotEqual(
            $removeDirectoryNumberResponse[ProvisioningConstant::A2_RESPONSE],
            ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
        ) {
            if ($this->_isDebugEnabled()) {
                $this->_debug('removeUserDirectoryNumber1 is failed for user '
                    . $userID . ' response is ' . $removeDirectoryNumberResponse[ProvisioningConstant::A2_RESPONSE]);
            }
            $this->_check_translated_response(
                $removeDirectoryNumberResponse,
                ApiResponseConstant::SUBSCRIBER_REMOVE_USER_DIRECTORY_NUMBER_CALL_FAILED);
        }

        $callExecutedList[] = 'removeUserDirectoryNumber1';

        $defaultStatus = $subscriberDetails['default_status'];
        if (UtilityMethods::isEqual($defaultStatus, ProvisioningConstant::DEFAULT_STATUS_ACTIVE)
            || UtilityMethods::isEqual($defaultStatus, ProvisioningConstant::DEFAULT_STATUS_TRIAL)) {

            $defaultOperation = false;
            if (
                $siteServiceInfo['is_default_subdomains_enabled']
                && $subscriberDetails['is_default_subdomain_subscriber']
                && UtilityMethods::isNotEmpty($siteServiceInfo['public_number'])
            ) {
                $siteSubscriberCount = SubscriberDao::getDefaultSubscriberCountBySite($connection, $siteServiceInfo['site_id'], $subscriberDetails['user_id']);
                $nationalFormatSPN = UtilityMethods::replaceIfStartsWith(
                    $subscriberDetails['sitePublicNumber'],
                    CommonConstant::DEFAULT_MODE_ETISALAT_E164_PREFIX,
                    CommonConstant::DEFAULT_MODE_SITE_PN_PREFIX
                );

                if ($nationalFormatSPN && $siteSubscriberCount == 0) {
                    $defaultOperation = true;
                    $subscriberDetails["voip_numbers"][] = $nationalFormatSPN;
                }
            }

            $response = $individualProv->setUserDirectoryNumber1($connection, $groupDetails, $subscriberDetails, true);

            if (
                $defaultOperation
                && UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
                && preg_match('/' . $nationalFormatSPN . '/', $response[ProvisioningConstant::A2_RESPONSE])
            ) {
                array_pop($subscriberDetails["voip_numbers"]);
                $response = $individualProv->setUserDirectoryNumber1($connection, $groupDetails, $subscriberDetails, true);
                $defaultOperation = false;
            }

            if (UtilityMethods::isNotEqual(
                $response[ProvisioningConstant::A2_RESPONSE], ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
            ) {

                if ($this->_isDebugEnabled()) {
                    $this->_debug('setUserDirectoryNumber1 is failed for user '
                        . $userID . ' response is ' . $response[ProvisioningConstant::A2_RESPONSE]);
                }

                $this->_set_directory_number_error_response($response);
                $this->_check_translated_response(
                    $response,
                    ApiResponseConstant::SUBSCRIBER_SET_USER_DIRECTORY_NUMBER_CALL_FAILED);
            } else if ($defaultOperation && $nationalFormatSPN) {
                $response = $individualProv->setDNandNQforDefaultUser1($connection, $groupDetails, $subscriberDetails, $nationalFormatSPN);
            }

            $callExecutedList[] = 'setUserDirectoryNumber1';

            $response = $individualProv->modifyUser($connection, $groupDetails, $subscriberDetails, $siteServiceInfo);

            if (UtilityMethods::isNotEqual(
                $response[ProvisioningConstant::A2_RESPONSE], ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
            ) {

                if ($this->_isDebugEnabled()) {
                    $this->_debug('modifyUser is failed for user '
                        . $userID . ' response is ' . $response[ProvisioningConstant::A2_RESPONSE]);
                }

                $this->_check_translated_response(
                    $response,
                    ApiResponseConstant::SUBSCRIBER_MODIFY_BUSINESS_NUMBER_FAILED);
            }
            $callExecutedList[] = 'modifyUser';
        }
    }

	// end of method _saveVoipDetails()
	private function _setCosForUser1($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		if (UtilityMethods::isEqual ( $subscriber_details ["default_status"], ProvisioningConstant::DEFAULT_STATUS_INACTIVE )) {
			$cos_array = array ();
			$domainProv = new models\external\prov\Domain ();
			$response = $domainProv->getAllDomainCos ( $connection, $group_details, $subscriber_details ["prov_system_id"] );
			if (is_array ( $response [ProvisioningConstant::A2_RESPONSE] )) {
				$lowest_cos = end ( $response [ProvisioningConstant::A2_RESPONSE] );
				$subscriber_details ['call_permission'] = $lowest_cos ["name"];
				$subscriber_details ['call_forward_permission'] = $lowest_cos ["name"];
			}
		}

		$response = $individualProv->setCosForUser1 ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _setCosForUser1 failed(setCosForUser1)  for user " . $subscriber_details ['user_id'] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_COS_FOR_USER_CALL_FAILED );
		}
		$call_executed_list [] = "setCosForUser1";
	}

	// end of method _setCosForUser1()
	private function _removeCosForUser1($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$response = $individualProv->removeCosForUser1 ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> removeCosForUser1 failed(setCosForUser1)  for user " . $subscriber_details ['user_id'] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_COS_FOR_USER_CALL_FAILED );
		}
		$call_executed_list [] = "removeCosForUser1";
	}

	// end of method _setCosForUser1()
	private function _setLocationForUser1($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$response = $individualProv->setLocationForUser1 ( $connection, $group_details, $subscriber_details );
		$get_location = $individualProv->getLocationForUser($connection, $group_details, $subscriber_details);
		$response_get_location = false;
		if(is_string($get_location)){
			$response_get_location = true;
		}
		if ((UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) || ($subscriber_details ["location_name"] =! $get_location) && $response_get_location) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _setLocationForUser1 failed(setLocationForUser1)  for user " . $subscriber_details ['user_id'] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_LOCATION_FOR_USER_CALL_FAILED );
		}
		$call_executed_list [] = "setLocationForUser1";
	}

	// end of method _setLocationForUser1()

    /**
     * Set subscriber's public number
     *
     * @param PDO $connection
     * @param object $group_details
     * @param array $subscriber_details
     * @param models\external\prov\Individual $individualProv
     * @param array $call_executed_list
     * @param array|null $oldSubscriberDetails
     * @throws Exception
     */
    private function _setUserChargeInfo($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list, $oldSubscriberDetails = null)
    {
        $psxFacade = new PSXFacade();
        if (!empty($subscriber_details['public_charge_id'])) {
            $psxResult = $psxFacade->addPSXNumber($group_details->group_id, $subscriber_details['public_charge_id'], false, false);
            if (isset($psxResult['ERROR_CODE'])) {
                throw new CallFailedException ('', $psxResult['ERROR_CODE']);
            }
        }
        if (
            !empty($oldSubscriberDetails)
            && isset($oldSubscriberDetails['public_charge_id'])
            && UtilityMethods::isNotEqual($subscriber_details['public_charge_id'], $oldSubscriberDetails['public_charge_id'])
        ) {
            $numberDetails = PstndidDao::get_pstn_did_details_by_number($connection, ltrim($oldSubscriberDetails['public_charge_id'], PSXConstant::E164_NUMBER_PREFIX));
            if ($numberDetails['purpose'] == PstndidConstant::PSTN_DID_PURPOSE_NONE) {
                $psxFacade->deletePSXNumber($group_details->group_id, $oldSubscriberDetails['public_charge_id'], false);
            }
        }

		$response = $individualProv->setUserChargeInfo1 ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _setUserChargeInfo failed(setUserChargeInfo1) for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
            $this->_check_translated_response($response, ApiResponseConstant::INVALID_PUBLIC_CHARGE_ID);
		}
		$call_executed_list [] = "setUserChargeInfo1";
	}

	// end of method _setUserChargeInfo()
	private function _removeUserChargeInfo($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$response = $individualProv->removeUserChargeInfo1 ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _removeUserChargeInfo failed(removeUserChargeInfo1) for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_USER_CHARGE_INFO_CALL_FAILED );
		}
		$call_executed_list [] = "removeUserChargeInfo1";
	}

	private function _setDNandNQforUser1($connection, $group_details, $subscriber_details, $site_service_information, $individualProv, &$call_executed_list) {

		/**
		 * As per the Basil request on Feb 09, 2016.
		 * Pbx users should not set setDNandNQforUser1.
		 */
		if (UtilityMethods::is_pbx_menu_bundle ( $subscriber_details ["menu"] )) {
			return;
		}
		if (UtilityMethods::isEqual ( $subscriber_details ["default_status"], ProvisioningConstant::DEFAULT_STATUS_ACTIVE ) && UtilityMethods::isNotEmpty ( $subscriber_details ["voice_mail_directory_number"] ) && (! isset ( $site_service_information ["sip_pbx_type"] ) || UtilityMethods::isNotEqual ( $site_service_information ["sip_pbx_type"], SiteConstant::SITE_PBX_TYPE_STATIC_SBC ))) {
			$response = $individualProv->setDNandNQforUser1 ( $connection, $group_details, $subscriber_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _setDNandNQforUser1 failed(setDNandNQforUser1) for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_DN_AND_NQ_USER_CALL_FAILED );
			}
			$call_executed_list [] = "setDNandNQforUser1";
		}
	}

	// end of method _setDNandNQforUser1()
	private function _updateUserAlias($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		if (ProvUtility::isSubscriberConfigured ( $subscriber_details ["subscriber_type"] )) {
            // Check if Voip Alias is given: ACL-21478
            if (isset($subscriber_details['voip_alias']) && !empty($subscriber_details['voip_alias'])) {
                $check = SubscriberDao::checkDuplicatedAlias(
                    $connection, $subscriber_details['voip_alias'], $subscriber_details['subscriber_id'], $subscriber_details['site_id'], $subscriber_details['group_id']
                );
                if ($check !== false) {
                    $this->_error("Voip alias " . $subscriber_details["voip_alias"] . " already exist...");
                    $this->_check_translated_response($check, ApiResponseConstant::SUBSCRIBER_USER_ALIAS_ALREADY_EXIST, $subscriber_details['voip_alias']);
                }

                // Check if the Alias is in use as a User ID: ACL-20913
                $aliasUserIDMatch = SubscriberDao::check_user_id_exist(
                    $connection,
                    $subscriber_details['voip_alias'] . '@' . $group_details->top_level_domain
                );

                if ($aliasUserIDMatch) {
                    $this->_check_translated_response(
                        [],
                        ApiResponseConstant::SUBSCRIBER_USER_ID_ALIAS_EXISTENCE,
                        $subscriber_details['voip_alias']
                    );
                }
            }

			$response = $individualProv->updateUserAlias ( $connection, $group_details, $subscriber_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _updateUserAlias failed(updateUserAlias) for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					if(preg_match("/Alias \"(.*)\" matches an existing username, directory number, user alias or service alias/", $response[ProvisioningConstant::A2_RESPONSE])){
						$this->_check_translated_response ("", ApiResponseConstant::SUBSCRIBER_USER_ALIAS_ALREADY_EXIST,$subscriber_details['voip_alias']);
                    } else if (preg_match("/User alias should not start with a '\.'/", $response[ProvisioningConstant::A2_RESPONSE])) {
                        $this->_check_translated_response($response, ApiResponseConstant::ALIAS_CANNOT_START_WITH_DOT);
                    } else {
					$this->_check_translated_response ("", ApiResponseConstant::SUBSCRIBER_UPDATE_USER_ALIAS_CALL_FAILED);
				}
			}
		}
		}
		$call_executed_list [] = "updateUserAlias";
	}

	// end of method _updateUserAlias()
	private function _setUsersVoicemailServer($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$response = $individualProv->setUsersVoicemailServer ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _setUsersVoicemailServer failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
            if (preg_match("/Voicemail number should be unique in a domain/", $response[ProvisioningConstant::A2_RESPONSE])) {
                $this->_check_translated_response($response, ApiResponseConstant::VOICE_DN_EXIST);
            } else {
                $this->_check_translated_response($response, ApiResponseConstant::SUBSCRIBER_SET_USER_VOICEMAIL_SERVER_CALL_FAILED);
            }
		}
		$call_executed_list [] = "setUsersVoicemailServer";
	}

	// end of method _setUsersVoicemailServer()
	private function _removeUsersVoicemailServer($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$response = $individualProv->removeUsersVoicemailServer ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _removeUsersVoicemailServer failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_USER_VOICEMAIL_SERVER_CALL_FAILED );
		}
		$call_executed_list [] = "removeUsersVoicemailServer";
	}

	// end of method _removeUsersVoicemailServer()
	private function _saveVoicemailDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
        if ($this->fromMigration) {
            return;
        }

        if (UtilityMethods::isEqual(CIM_PIN_MIN_LENGTH, 'FALSE')) {
            if (strlen($subscriber_details['voicemail_pin']) < 4
                && ProvUtility::isVoicemailServiceHosted($subscriber_details['voicemail_service'])) {
                $this->_check_translated_response('', ApiResponseConstant::SUBSCRIBER_CREATE_VOICEMAIL_CALL_FAILED);
            }else{
				$this->_checkAndCreateVoiceMailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}
        }else {
            if (strlen($subscriber_details['voicemail_pin']) < 6
                && ProvUtility::isVoicemailServiceHosted($subscriber_details['voicemail_service'])) {
                $this->_check_translated_response('', ApiResponseConstant::SUBSCRIBER_CREATE_VOICEMAIL_CALL_FAILED);
            }else{
                $this->_checkAndCreateVoiceMailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
            }
        }
	}

	// end of method _saveVoicemailDetails()
	private function _checkAndCreateVoiceMailDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		if (ProvUtility::isVoicemailServiceHosted ( $subscriber_details ["voicemail_service"] )) {
            $response = $individualProv->createVoicemail ( $connection, $group_details, $subscriber_details );
            if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
                if ($this->_isDebugEnabled ()) {
                    $this->_debug ( " Subscriber Facade -> _saveVoicemailDetails(createVoicemail) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
                }
                if ((strpos($response [ProvisioningConstant::A2_RESPONSE], 'Add Failed:Number already exists.')) !== false) {
                    $this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_PSTN_DID_NUMBER_ALREADY_IN_USE );
                } elseif ((strpos($response [ProvisioningConstant::A2_RESPONSE], '1003')) !== false) {
                    if (strpos($response[ProvisioningConstant::A2_RESPONSE], 'The pin must be between')) {
                        $this->_check_translated_response($response, ApiResponseConstant::INVALID_VOICEMAIL_PIN_LENGTH);
                    }
                    $this->_check_translated_response($response, ApiResponseConstant::INVALID_VOICEMAIL_PIN);
                }  else {
                    $this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_CREATE_VOICEMAIL_CALL_FAILED );
                }
            }
            $call_executed_list [] = "createVoicemail";
            if (ProvUtility::isUreachDeviceType ( $group_details->voice_mail_device_type )) {
                $paProv = new models\external\prov\pa\Pa ();
                $response = $paProv->SetPhoneSettings ( $connection, $subscriber_details );
                if (is_string ( $response [ProvisioningConstant::A2_RESPONSE] ) && ! preg_match ( "/Failed/i", $response [ProvisioningConstant::A2_RESPONSE] )) {
                    $call_executed_list [] = "SetPhoneSettings";
                }
            }
        }
        if (ProvUtility::isSubscriberConfigured ( $subscriber_details ["subscriber_type"] )) {
            $this->_setUsersVoicemailServer ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
		}
	}

	// end of method _saveVoicemailDetails()
	private function _updateVoicemailDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
        if ($this->fromMigration) {
            return;
        }

		$response = $individualProv->modifyVoicemail ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _updateVoicemailDetails(modifyVoicemail) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			if ((strpos($response [ProvisioningConstant::A2_RESPONSE], 'AddNumber: number already exists')) !== false) {
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_PSTN_DID_NUMBER_ALREADY_IN_USE );
            } elseif (preg_match('/Pin is not numeric/', $response[ProvisioningConstant::A2_RESPONSE])) {
                $this->_check_translated_response($response, ApiResponseConstant::INVALID_VOICEMAIL_PIN);
            } else if (strpos($response[ProvisioningConstant::A2_RESPONSE], 'The pin must be between')) {
                $this->_check_translated_response($response, ApiResponseConstant::INVALID_VOICEMAIL_PIN_LENGTH);
            } else {
                $this->_check_translated_response($response, ApiResponseConstant::SUBSCRIBER_MODIFY_VOICEMAIL_CALL_FAILED);
            }
		}
		$call_executed_list [] = "modifyVoicemail";
		if (ProvUtility::isSubscriberConfigured ( $subscriber_details ["subscriber_type"] )) {
			$this->_setUsersVoicemailServer ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
		}
	}

	// end of method _updateVoicemailDetails()
	private function _saveMeetmeDetails($connection, $group_details, $subscriber_details, $old_subscriber_details, $individualProv, &$call_executed_list) {
		if ($this->_is_field_not_empty ( $subscriber_details, "meetme_access_code" ) || $this->_is_field_not_empty ( $subscriber_details, "voice_mail_directory_number" )) {
			$response = $individualProv->setMeetmeDetails ( $connection, $group_details, $subscriber_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
                if ($this->_isDebugEnabled()) {
                    $this->_debug('_saveMeetmeDetails failed  for user '
                        . $subscriber_details['user_id']
                        . ' response is ' . $response[ProvisioningConstant::A2_RESPONSE]
                    );
                    if (
                    preg_match(
                        SubscriberConstant::MEETME_ACCESS_CODE_ALREADY_IN_USE,
                        $response[ProvisioningConstant::A2_RESPONSE]
                    )
                    ) {
                        $this->_check_translated_response(
                            $response,
                            ApiResponseConstant::SUBSCRIBER_SET_MEETME_DETAILS_CALL_FAILED,
                            $subscriber_details['meetme_access_code']
                        );
                    } else if (
                        preg_match(
                            SubscriberConstant::NON_NUMERIC_MEETME_ACCESS_CODE,
                            $response[ProvisioningConstant::A2_RESPONSE]
                        )
                    ) {
                        $this->_check_translated_response(
                            $response,
                            ApiResponseConstant::SUBSCRIBER_SET_MEETME_ACCESS_CODE_FAILED
                        );
                    } else {
                        $this->_check_translated_response(
                            $response,
                            ApiResponseConstant::SUBSCRIBER_UPDATE_USER_ALIAS_CALL_FAILED
                        );
                    }
                }
			}
			$call_executed_list [] = "setMeetmeDetails";

			/**
			 * RE: ACL-1701 Change of Meetme AccessCode needs to update MEP - Clarification
			 * Standalone meetme does not include MEP
			 */
			if (UtilityMethods::is_non_standalone_meetme_menu_bundle ( $subscriber_details ["menu"] ) && MEP_AVILABLE_IN_SOLUTION) {
				$meetme_access_code = UtilityMethods::getValueFromArray ( $subscriber_details, "meetme_access_code", NULL );
				if (UtilityMethods::isEmpty ( $meetme_access_code )) {
					$meetme_access_code = $subscriber_details ["voice_mail_directory_number"];
				}

				if (UtilityMethods::isEmpty ( $old_subscriber_details )) {
					$old_subscriber_details = array ();
				}
				$old_meetme_access_code = UtilityMethods::getValueFromArray ( $old_subscriber_details, "meetme_access_code", NULL );
				if (UtilityMethods::isEmpty ( $old_meetme_access_code ) && isset ( $old_subscriber_details ["voice_mail_directory_number"] ) && ! empty ( $old_subscriber_details ["voice_mail_directory_number"] )) {
					$old_meetme_access_code = $old_subscriber_details ["voice_mail_directory_number"];
				}

				if (UtilityMethods::isNotEmpty ( $old_meetme_access_code ) && UtilityMethods::isNotEqual ( $meetme_access_code, $old_meetme_access_code )) {
					$response = $individualProv->MEPsetUserAttribute ( $connection, $group_details, $subscriber_details );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isErrorEnabled ()) {
							$this->_error ( " Subscriber Facade -> MEPsetUserAttribute failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}
					}
					$call_executed_list [] = "MEPsetUserAttribute";
				}
			}
		}
	}

	// end of method _saveMeetmeDetails()
	private function _removeMeetMeDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		if ($this->_is_field_not_empty ( $subscriber_details, "meetme_access_code" ) || $this->_is_field_not_empty ( $subscriber_details, "voice_mail_directory_number" )) {
			$response = $individualProv->removeMeetMeConfUser1 ( $connection, $group_details, $subscriber_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _removeMeetMeDetails failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_MEETME_DETAILS_CALL_FAILED );
			}
			$call_executed_list [] = "removeMeetMeDetails";
		}
	}

	// end of method _removeMeetMeDetails()
	private function _setUserProfile_VideoCollabAdminService($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list, $smart_office_details) {
		if ($this->_is_field_not_empty ( $subscriber_details, "conference_extn_number" )) {
			$response = $individualProv->setUserProfile_VideoCollabAdminService ( $connection, $group_details, $subscriber_details, $smart_office_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _setUserProfile_VideoCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_SO_VIDEO_CALL_FAILED );
			}
			$call_executed_list [] = "setUserProfile_VideoCollabAdminService";
		}
	}

	// end of method _setUserProfile_VideoCollabAdminService()
	private function _modifyUserProfile_VideoCollabAdminService($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list, $smart_office_details) {
		if ($this->_is_field_not_empty ( $subscriber_details, "conference_extn_number" )) {
			$response = $individualProv->modifyUserProfile_VideoCollabAdminService ( $connection, $group_details, $subscriber_details, $smart_office_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if (is_string ( $response [ProvisioningConstant::A2_RESPONSE] ) && preg_match ( "/software error occurred/i", $response [ProvisioningConstant::A2_RESPONSE] )) {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> _modifyUserProfile_VideoCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] . " calling _setUserProfile_VideoCollabAdminService again..." );
					}
					$response = $individualProv->setUserProfile_VideoCollabAdminService ( $connection, $group_details, $subscriber_details, $smart_office_details );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> _setUserProfile_VideoCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}
						$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_SO_VIDEO_CALL_FAILED );
					}
				} else {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> _modifyUserProfile_VideoCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					}
					$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_SO_VIDEO_CALL_FAILED );
				}
			}
			$call_executed_list [] = "modifyUserProfile_VideoCollabAdminService";
		}
	}

	// end of method _modifyUserProfile_VideoCollabAdminService()
	private function _removeUserProfile_VideoCollabAdminService($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$response = $individualProv->removeUserProfile_VideoCollabAdminService ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _removeUserProfile_VideoCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_SO_VIDEO_CALL_FAILED );
		}
		$call_executed_list [] = "removeUserProfile_VideoCollabAdminService";
	}

	// end of method _removeUserProfile_VideoCollabAdminService()
	private function _setUserProfile_WebCollabAdminService($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list, $smart_office_details) {
		if ($this->_is_field_not_empty ( $subscriber_details, "conference_extn_number" )) {
			$response = $individualProv->setUserProfile_WebCollabAdminService ( $connection, $group_details, $subscriber_details, $smart_office_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _setUserProfile_WebCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_SO_WEB_CALL_FAILED );
			}
			$call_executed_list [] = "setUserProfile_WebCollabAdminService";
		}
	}

	// end of method _setUserProfile_WebCollabAdminService()
	private function _modifyUserProfile_WebCollabAdminService($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list, $smart_office_details) {
		if ($this->_is_field_not_empty ( $subscriber_details, "conference_extn_number" )) {
			$response = $individualProv->modifyUserProfile_WebCollabAdminService ( $connection, $group_details, $subscriber_details, $smart_office_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if (is_string ( $response [ProvisioningConstant::A2_RESPONSE] ) && preg_match ( "/software error occurred/i", $response [ProvisioningConstant::A2_RESPONSE] )) {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> _modifyUserProfile_WebCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] . " calling _setUserProfile_WebCollabAdminService again..." );
					}
					$response = $individualProv->setUserProfile_WebCollabAdminService ( $connection, $group_details, $subscriber_details, $smart_office_details );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> _setUserProfile_WebCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}
						$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_SO_WEB_CALL_FAILED );
					}
				} else {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> _modifyUserProfile_WebCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					}
					$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_SO_WEB_CALL_FAILED );
				}
			}
			$call_executed_list [] = "modifyUserProfile_WebCollabAdminService";
		}
	}

	// end of method _modifyUserProfile_WebCollabAdminService()
	private function _removeUserProfile_WebCollabAdminService($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$response = $individualProv->removeUserProfile_WebCollabAdminService ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _removeUserProfile_WebCollabAdminService failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_SO_WEB_CALL_FAILED );
		}
		$call_executed_list [] = "removeUserProfile_WebCollabAdminService";
	}

	// end of method _removeUserProfile_WebCollabAdminService()
	private function _saveSmartOfficeDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list, $old_subscriber_details, $is_service_set_changed) {
		$old_menu = $old_subscriber_details ["menu"];
		$menu = $subscriber_details ["menu"];

		$old_so_video = false;
		$old_so_screen_share = false;
		if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $old_menu ) && $this->_is_field_not_empty ( $old_subscriber_details, "conference_extn_number" )) {
			$old_so_video = true;
		}
		if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $old_menu ) && $this->_is_field_not_empty ( $old_subscriber_details, "conference_extn_number" )) {
			$old_so_screen_share = true;
		}

		$so_video = false;
		$so_screen_share = false;

		if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu ) && $this->_is_field_not_empty ( $subscriber_details, "conference_extn_number" )) {
			$so_video = true;
		}
		if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu ) && $this->_is_field_not_empty ( $subscriber_details, "conference_extn_number" )) {
			$so_screen_share = true;
		}

		$smart_office_details = array ();
		if ($so_video || $so_screen_share) {
			$smart_office_group_id = $this->_get_smart_office_group_id ( $group_details );
			$smart_office_details ["so_proxy_name"] = SmartOfficeProxyDao::get_so_proxy_name ( $connection, $subscriber_details ["smart_office_proxy_id"] );

			$smart_office_service_sets = ServiceSetDao::get_service_sets_by_menu_names ( $connection, array (
					ProvisioningConstant::menu_name_smart_office_video_collab,
					ProvisioningConstant::menu_name_smart_office_web_collab
			) );

			$service_set_array = explode ( "|", $subscriber_details ["service_set_value"] );

			$so_service_set = array_values ( array_intersect ( $service_set_array, $smart_office_service_sets ) );
			$smart_office_details ['so_group'] = SmartOfficeGroupDao::get_group_by_service_set_name ( $connection, $so_service_set [0] );
			$smart_office_details ['so_location'] = SMART_OFFICE_LOCATION;
		}

		if ($so_video) {
			if (!in_array ( "modifyUserServiceSets", $call_executed_list )) {
				$this->_modifyUserProfile_VideoCollabAdminService ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $smart_office_details );
			} else {
				$this->_setUserProfile_VideoCollabAdminService ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $smart_office_details );
			}
		}

		if ($so_screen_share) {
			if (!in_array ( "modifyUserServiceSets", $call_executed_list )) {
				$this->_modifyUserProfile_WebCollabAdminService ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $smart_office_details );
			} else {
				$this->_setUserProfile_WebCollabAdminService ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $smart_office_details );
			}
		}
	}

	// end of method _saveSmartOfficeDetails()
	private function _saveCallgrabberDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$response = $individualProv->setCallGrabDetails ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _saveCallgrabberDetails failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
            if (strpos($response [ProvisioningConstant::A2_RESPONSE], 'one or more digits') !== false) {
                $this->_check_translated_response($response, ApiResponseConstant::INVALID_CALL_GRABBER_NUMBER);
            } else {
                $this->_check_translated_response($response, ApiResponseConstant::SUBSCRIBER_UNABLE_TO_UPDATE_CALL_PARTY_MUST_BE_UNIQUE);
            }
		}
		$call_executed_list [] = "setCallGrabDetails";
	}

	// end of method _saveCallgrabberDetails()
	private function _enableMepExtensionDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		if (! in_array ( "setUserDirectoryNumber1", $call_executed_list )) {
			$response = $individualProv->setUserDirectoryNumber1 ( $connection, $group_details, $subscriber_details, true );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _enableMepExtensionDetails(setUserDirectoryNumber1) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_set_directory_number_error_response($response);
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_USER_DIRECTORY_NUMBER_CALL_FAILED );
			}
			$call_executed_list [] = "setUserDirectoryNumber1";
		}

		if ($this->_is_field_not_empty ( $subscriber_details, "mobile_number" )) {
			$mep_ext_response = $individualProv->enableMobileExtension ( $connection, $group_details, $subscriber_details );
			if (UtilityMethods::isNotEqual ( $mep_ext_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _enableMepExtensionDetails failed  for user " . $subscriber_details ["user_id"] . " response is " . $mep_ext_response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $mep_ext_response, ApiResponseConstant::SUBSCRIBER_ENABLE_MOBILE_EXTENSION_CALL_FAILED );
			}
			$call_executed_list [] = "enableMobileExtension";
		}
	}

	// end of method _enableMepExtensionDetails()
	private function _modifyMepExtensionDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		if (! in_array ( "removeMobileExtensionUserData", $call_executed_list )) {
			$response = $individualProv->removeMobileExtensionUserData ( $connection, $group_details, $subscriber_details, true );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _modifyMepExtensionDetails(removeMobileExtensionUserData) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_MOBILE_EXTENSION_USER_DATA_CALL_FAILED );
			}
			$call_executed_list [] = "removeMobileExtensionUserData";
		}

		if (! in_array ( "setUserDirectoryNumber1", $call_executed_list )) {
			$response = $individualProv->setUserDirectoryNumber1 ( $connection, $group_details, $subscriber_details, true );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _modifyMepExtensionDetails(setUserDirectoryNumber1) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_set_directory_number_error_response($response);
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_USER_DIRECTORY_NUMBER_CALL_FAILED );
			}
			$call_executed_list [] = "setUserDirectoryNumber1";
		}

		if ($this->_is_field_not_empty ( $subscriber_details, "mobile_number" )) {
			$mep_ext_response = $individualProv->modifyMobileExtension ( $connection, $group_details, $subscriber_details );
			if (UtilityMethods::isNotEqual ( $mep_ext_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _modifyMepExtensionDetails failed  for user " . $subscriber_details ["user_id"] . " response is " . $mep_ext_response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $mep_ext_response, ApiResponseConstant::SUBSCRIBER_MODIFY_MOBILE_EXTENSION_USER_DATA_CALL_FAILED );
			}
			$call_executed_list [] = "modifyMobileExtensionUserData";
		}
	}

	// end of method _enableMepExtensionDetails()
	private function _disableMepExtensionDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
		$mep_ext_response = $individualProv->disableMobileExtension ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $mep_ext_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _disableMepExtensionDetails failed  for user " . $subscriber_details ["user_id"] . " response is " . $mep_ext_response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $mep_ext_response, ApiResponseConstant::SUBSCRIBER_DISABLE_MOBILE_EXTENSION_CALL_FAILED );
		}
		$call_executed_list [] = "disableMobileExtension";
	}

	// end of method _disableMepExtensionDetails()
	private function _saveMepDetails($connection, $group_details, $subscriber_details, $individualProv, &$call_executed_list) {
        if (!MEP_AVILABLE_IN_SOLUTION){
            return;
        }
		$response = $individualProv->saveMobilityService ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _saveMepDetails(saveMobilityService) failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SAVE_MOBILITY_SERVICE_CALL_FAILED );
		}
		$call_executed_list [] = "saveMobilityService";
	}

	// end of method _saveMepDetails()
	private function _addCallRecordingUser($connection, $service_set_value, $group_details, $subscriber_details, $orekaProv, &$call_executed_list) {
		if ($this->has_pbx_menu_bundle($connection,$service_set_value)) {
			$groupId = $group_details->group_id;
			$site_details = SiteDao::get_site_details ( $connection, $groupId, $subscriber_details ["site_identifier"] );
			$accessIp = $this->get_access_ip ( $connection, $subscriber_details ["site_identifier"],$groupId);
			$pbxIp = $site_details ["sip_pbx_ip_address"];
			$accessIps = array (
					$accessIp,
					$pbxIp
			);
			$extendedUserIds = $this->get_extended_userIds ( $subscriber_details ["voip_numbers"], $accessIps );
			$subscriber_details ["extended_userids"][] = $extendedUserIds;
			$call_record_response = $orekaProv->addCallRecordingUser ( $connection, $group_details, $subscriber_details );
			unset ( $subscriber_details ["extended_userids"] );
		} else {
			$call_record_response = $orekaProv->addCallRecordingUser ( $connection, $group_details, $subscriber_details );
		}

		$call_record_response = $orekaProv->addCallRecordingUser ( $connection, $group_details, $subscriber_details );
		if (UtilityMethods::isNotEqual ( $call_record_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> _addCallRecordingUser failed  for user " . $subscriber_details ["user_id"] . " response is " . $call_record_response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_send_call_recording_notifications ( "Add", $group_details, $subscriber_details, "oreka=>addUser() failed." );
			$this->_check_translated_response ( $call_record_response, ApiResponseConstant::SUBSCRIBER_ADD_CALL_RECORDING_USER_CALL_FAILED );
		}
		$call_executed_list [] = "addCallRecordingUser => addUser";
		$this->_send_call_recording_notifications ( "Add", $group_details, $subscriber_details, "" );
	}

	// end of method _addcallRecordingUser()
	private function _removeCallRecordingUser($connection, $group_details, $subscriber_details, $orekaProv, &$call_executed_list) {
		$this->_send_call_recording_notifications ( "Removed", $group_details, $subscriber_details, "" );
	}
    // end of method _removeCallRecordingUser()

    /**
     * Internal Method to delete voicemail details
     *
     * @param PDO $connection
     * @param object $groupDetails
     * @param array $subscriberDetails
     * @param object $individualProv
     * @param array $callExecutedList
     *
     * @return void
     * @throws Exception
     */
    private function _deleteVoicemailDetails(
        $connection,
        $groupDetails,
        $subscriberDetails,
        $individualProv,
        &$callExecutedList
    ) {
        if ($this->fromMigration) {
            return;
        }

        $response = $individualProv->findAndDeleteVoicemail($connection, $groupDetails, $subscriberDetails);
        if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
            $this->_debug(" Subscriber Facade -> _deleteVoicemailDetails failed  for user " . $subscriberDetails["user_id"] . " response is " . $response[ProvisioningConstant::A2_RESPONSE]);
            $this->_check_translated_response($response, ApiResponseConstant::SUBSCRIBER_FIND_AND_DELETE_VOICEMAIL_CALL_FAILED);
        }
        $callExecutedList[] = "findAndDeleteVoicemail";
        if (ProvUtility::isSubscriberConfigured($subscriberDetails["subscriber_type"]) && (!UtilityMethods::is_non_standalone_auto_attendant_related_menu_bundle($subscriberDetails["menu"]) || ProvUtility::isVoicemailServicePermise($subscriberDetails["voicemail_service"]))) {
            $this->_removeUsersVoicemailServer($connection, $groupDetails, $subscriberDetails, $individualProv, $callExecutedList);
        }
    }

    // end of method _deleteVoicemailDetails()

    /**
     * Internal Method to delete subscriber
     *
     * @param PDO $connection
     * @param object $groupDetails
     * @param array $subscriberDetails
     * @param object $individualProv
     * @param array $callExecutedList
     *
     * @return void
     */
    private function _deleteSubscriber(
        $connection,
        $groupDetails,
        $subscriberDetails,
        $individualProv,
        &$callExecutedList
    ) {
        $responseArray = [];
        if ($this->isItOperation()) {
            $this->_debug(" Subscriber Facade -> _deleteSubscriber -> " . $subscriberDetails["user_id"] . " response is INSUFFICIENT_PERMISSIONS");
            $responseArray["ERROR_CODE"] = ApiResponseConstant::IT_OPERATIONS_PERMISSION_RULE;
            return $responseArray;
        }
        if (UtilityMethods::is_voicemail_menu_bundle($subscriberDetails["menu"]) && !$this->fromMigration) {
            $this->_deleteVoicemailDetails($connection, $groupDetails, $subscriberDetails, $individualProv, $callExecutedList);
        } // end of if(SS = VM)

        //Delete rich messaging on cim
        if (
            UtilityMethods::is_rich_messaging_menu_bundle($subscriberDetails["menu"])
            && (
                ($this->fromMigration && $this->isDomainChanged)
                || !$this->fromMigration
            )
        ) {
            $cimResponse = $individualProv->deleterRichMessagingAccount($connection, $groupDetails, $subscriberDetails);
            if (UtilityMethods::isNotEqual($cimResponse[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                $this->_error(" Subscriber Facade -> _deleteRichMessaging -> on CIM failed for user " . $subscriberDetails["user_id"] . ". response is " . $cimResponse[ProvisioningConstant::A2_RESPONSE]);
            }
            $callExecutedList[] = 'deleteRichMessagingAccount';
        }

        if (ProvUtility::isSubscriberConfiguredOrSipTrunk($subscriberDetails["subscriber_type"])) {

            if (UtilityMethods::is_smart_office_video_collab_menu_bundle($subscriberDetails["menu"])) {
                $response = $individualProv->removeUserProfile_VideoCollabAdminService($connection, $groupDetails, $subscriberDetails);
                if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                    $this->_error(" Subscriber Facade -> _deleteSubscriber -> _removeUserProfile_VideoCollabAdminService failed for user " . $subscriberDetails["user_id"] . " response is " . $response[ProvisioningConstant::A2_RESPONSE]);
                }
            }
            if (UtilityMethods::is_smart_office_web_collab_menu_bundle($subscriberDetails["menu"])) {
                $response = $individualProv->removeUserProfile_WebCollabAdminService($connection, $groupDetails, $subscriberDetails);
                if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                    $this->_error(" Subscriber Facade -> _deleteSubscriber -> _removeUserProfile_WebCollabAdminService failed for user " . $subscriberDetails["user_id"] . " response is " . $response[ProvisioningConstant::A2_RESPONSE]);
                }
            }

            $response = $individualProv->deleteUser($connection, $groupDetails, $subscriberDetails);
            if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                if (UtilityMethods::isEqual($response[ProvisioningConstant::A2_RESPONSE], "Failed - no such user")) {
                    $this->_error(print_r("No user existed on AS======>", TRUE) . PHP_EOL);
                }
                $this->_error(" Subscriber Facade -> _deleteSubscriber failed  for user " . $subscriberDetails["user_id"] . " response is " . $response[ProvisioningConstant::A2_RESPONSE]);
                $this->_check_translated_response($response, ApiResponseConstant::SUBSCRIBER_DELETE_USER_CALL_FAILED);
            }
            $callExecutedList[] = '_deleteUser';
        }
    }

    // end of method _deleteSubscriber()

    /**
     * Internal Method to delete voicemail details for rollback only
     *
     * @param PDO $connection
     * @param object $groupDetails
     * @param array $subscriberDetails
     * @param object $individualProv
     * @param array $callExecutedList
     *
     * @return void
     */
    private function _rollbackRemoveVoicemailDetails(
        $connection,
        $groupDetails,
        $subscriberDetails,
        $individualProv,
        &$callExecutedList
    ) {
        try {
            $response = $individualProv->findAndDeleteVoicemail($connection, $groupDetails, $subscriberDetails);
            if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                $this->_debug(" Subscriber Facade -> _rollbackRemoveVoicemailDetails failed  for user " . $subscriberDetails["user_id"] .
                " response is " . $response[ProvisioningConstant::A2_RESPONSE]);
                $this->_check_translated_response($response, ApiResponseConstant::SUBSCRIBER_FIND_AND_DELETE_VOICEMAIL_CALL_FAILED);
            }
            $callExecutedList[] = "findAndDeleteVoicemail";
        } catch (Exception $e) {
            $this->_error("Find and Delete Voicemail for rollback failed!", $e);
        }

        try {
            if (
                ProvUtility::isSubscriberConfigured($subscriberDetails["subscriber_type"]) &&
                (!UtilityMethods::is_non_standalone_auto_attendant_related_menu_bundle($subscriberDetails["menu"]) ||
                ProvUtility::isVoicemailServicePermise($subscriberDetails["voicemail_service"]))
            ) {
                $this->_removeUsersVoicemailServer($connection, $groupDetails, $subscriberDetails, $individualProv, $callExecutedList);
            }
        } catch (Exception $e) {
            $this->_error("Remove Users Voicemail Server for rollback failed!", $e);
        }
    }

    // end of method _deleteVoicemailDetails()

    /**
     * Internal Method to delete subscriber for rollback only
     *
     * @param PDO $connection
     * @param object $groupDetails
     * @param array $subscriberDetails
     * @param object $individualProv
     * @param array $callExecutedList
     *
     * @return void
     */
    private function _rollbackRemoveSubscriber(
        $connection,
        $groupDetails,
        $subscriberDetails,
        $individualProv,
        &$callExecutedList
    ) {
        $responseArray = [];
        if ($this->isItOperation()) {
            $this->_error(" Subscriber Facade -> _rollbackRemoveSubscriber -> " . $subscriberDetails["user_id"] . " response is INSUFFICIENT_PERMISSIONS");
            $responseArray["ERROR_CODE"] = ApiResponseConstant::IT_OPERATIONS_PERMISSION_RULE;
            return $responseArray;
        }
        try {
            if (UtilityMethods::is_voicemail_menu_bundle($subscriberDetails["menu"]) && !$this->fromMigration) {
                $this->_rollbackRemoveVoicemailDetails($connection, $groupDetails, $subscriberDetails, $individualProv, $callExecutedList);
            } // end of if(SS = VM)

            //Delete rich messaging on cim
            if (UtilityMethods::is_rich_messaging_menu_bundle($subscriberDetails["menu"])) {
                $cimResponse = $individualProv->deleterRichMessagingAccount($connection, $groupDetails, $subscriberDetails);
                if (UtilityMethods::isNotEqual($cimResponse[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                    $this->_error(" Subscriber Facade -> _deleteRichMessaging -> on CIM failed for user " . $subscriberDetails["user_id"]
                        . ". response is " . $cimResponse[ProvisioningConstant::A2_RESPONSE]);
                }
                $callExecutedList[] = 'deleteRichMessagingAccount';
            }
        } catch (Exception $e) {
            $this->_error("Delete Voicemail Details or Rich Messaging Account for rollback failed!", $e);
        }

        try {
            if (ProvUtility::isSubscriberConfiguredOrSipTrunk($subscriberDetails["subscriber_type"])) {

                if (UtilityMethods::is_smart_office_video_collab_menu_bundle($subscriberDetails["menu"])) {
                    $response = $individualProv->removeUserProfile_VideoCollabAdminService($connection, $groupDetails, $subscriberDetails);
                    if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                        $this->_error(" Subscriber Facade -> _rollbackRemoveSubscriber -> _removeUserProfile_VideoCollabAdminService failed for user "
                        . $subscriberDetails["user_id"] . " response is " . $response[ProvisioningConstant::A2_RESPONSE]);
                    }
                }
                if (UtilityMethods::is_smart_office_web_collab_menu_bundle($subscriberDetails["menu"])) {
                    $response = $individualProv->removeUserProfile_WebCollabAdminService($connection, $groupDetails, $subscriberDetails);
                    if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                        $this->_error(" Subscriber Facade -> _rollbackRemoveSubscriber -> _removeUserProfile_WebCollabAdminService failed for user "
                        . $subscriberDetails["user_id"] . " response is " . $response[ProvisioningConstant::A2_RESPONSE]);
                    }
                }

                $response = $individualProv->deleteUser($connection, $groupDetails, $subscriberDetails);
                if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                    if (preg_match("/" . SubscriberConstant::USER_NOT_FOUND_IN_DOMAIN . "/", $response[ProvisioningConstant::A2_RESPONSE])) {
                        $this->_error(print_r("No user existed on AS in domain: " . $subscriberDetails["domain"] . "======>", TRUE) . PHP_EOL);
                    }
                    $this->_error(" Subscriber Facade -> _rollbackRemoveSubscriber failed  for user " . $subscriberDetails["user_id"] . " response is "
                    . $response[ProvisioningConstant::A2_RESPONSE]);
                    $this->_check_translated_response($response, ApiResponseConstant::SUBSCRIBER_DELETE_USER_CALL_FAILED);
                }
                $callExecutedList[] = '_deleteUser';
            }
        } catch (Exception $e) {
            $this->_error("Delete details from A2 for rollback failed!", $e);
        }
    }

	// end of method _deleteSubscriber()
	// method to add campiagn number in A2
	private function _add_campaign_number($connection, $campaign_number, $subscriber_details, &$call_executed_list) {
		$campaignnumber_prov = new models\external\prov\CampaignNumber ();
		$people_details = SubscriberDao::get_subscriber_details_for_campaign_number ( $connection, $subscriber_details ['group_id'], $subscriber_details ['subscriber_id'] );
		$people_details ['campaign_number'] = $campaign_number;
		$response = $campaignnumber_prov->addCampaignNumber ( $connection, $people_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> add_campaign_number failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_ADD_CAMPAIGN_NUMBER_CALL_FAILED );
		}
		$call_executed_list [] = "addCampaignNumber";
	}

	// method to modify campiagn number in A2
	private function _modify_campaign_number($connection, $campaign_number, $subscriber_details, &$call_executed_list) {
		$campaignnumber_prov = new models\external\prov\CampaignNumber ();
		$people_details = SubscriberDao::get_subscriber_details_for_campaign_number ( $connection, $subscriber_details ['group_id'], $subscriber_details ['subscriber_id'] );
		$people_details ['campaign_number'] = $campaign_number;
		$response = $campaignnumber_prov->modifyCampaignNumber ( $connection, $people_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> modifyCampaignNumber failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_CAMPAIGN_NUMBER_CALL_FAILED );
		}
		$call_executed_list [] = "modifyCampaignNumber";
	}

	// method to remove campiagn number in A2
	private function _remove_campaign_number($connection, $campaign_number, $subscriber_details, &$call_executed_list) {
		$campaignnumber_prov = new models\external\prov\CampaignNumber ();
		$people_details = SubscriberDao::get_subscriber_details_for_campaign_number ( $connection, $subscriber_details ['group_id'], $subscriber_details ['subscriber_id'] );
		$people_details ['campaign_number'] = $campaign_number;
		$response = $campaignnumber_prov->removeCampaignNumber ( $connection, $people_details );
		if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " Subscriber Facade -> removeCampaignNumber failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
			}
			$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_CAMPAIGN_NUMBER_CALL_FAILED );
		}
		$call_executed_list [] = "removeCampaignNumber";
	}
	public function delete_node_subscriber_details($subscriber_user_id, $group_details) {
		$response_array = array ();
		if($this->isItOperation()) {
            if ($this->_isDebugEnabled()) {
                $this->_debug("INSUFFICIENT PERMISSIONS");
            }
            $response_array ["ERROR_CODE"] = ApiResponseConstant::IT_OPERATIONS_PERMISSION_RULE;
            return $response_array;
        }
		$group_domain = $group_details->top_level_domain;
		if (UtilityMethods::isSMB ( $group_details->group_type )) {
			$group_domain = $group_details->smb_prefix . "." . $group_details->top_level_domain;
		}
		$connection = DbConnector::getConnection ();
		$subscriber_details = $this->_get_subscriber_details ( $connection, $subscriber_user_id, $group_details, true );
		if (array_key_exists ( "ERROR_CODE", $subscriber_details )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Invalid Subscriber user Id..." . $subscriber_user_id );
			}
			return $subscriber_details;
		} // end of if($subscriber_details === false)
		$subscriber_type = $subscriber_details ["subscriber_type"];
		if (ProvUtility::isSubscriberStatusNotActive ( $subscriber_details ["status"] )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Status is Not Active for user Id..." . $subscriber_user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::RESOURCE_NOT_EXISTS;
			return $response_array;
		}
		if (! ProvUtility::isSubscriberNodType ( $subscriber_type )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Status does not belong to NOD Type for user Id..." . $subscriber_user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::RESOURCE_NOT_EXISTS;
			return $response_array;
		}
		try {
			$connection->beginTransaction ();
			if (ProvUtility::isDefaultStatusActive ( $subscriber_details ["default_status"] )) {
				SubscriberDao::insert_subscriber_invoice_details ( $connection, $subscriber_details, ReportConstant::SUBSCRIBER_INVOICE_REMOVED_STATUS, $group_domain, ProvUtility::getPstnDidGroupId ( $group_details ) );
			}
			SubscriberDao::delete_subscriber ( $connection, $subscriber_details ["subscriber_id"], $group_details->group_id );
			$this->_add_remove__subscriber_notices ( $connection, $group_details->group_id );
			$individualProv = new models\external\prov\Individual ();

			$response = $individualProv->deleteUser ( $connection, $group_details, $subscriber_details );
			if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Subscriber Facade -> _deleteSubscriber failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
				}
				$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_DELETE_USER_CALL_FAILED );
			}
			DbConnector::commitTransaction ( $connection );
		} catch ( Exception $e ) {
			DbConnector::rollbackTransaction ( $connection );
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Delete NOD Subscriber failed..." . $subscriber_user_id );
				$this->_error ( $e->getTraceAsString () );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::UNABLE_TO_DELETE_SUBSCRIBER;
		}
		return $response_array;
	}

	// end of method delete_node_subscriber_details()
	public function delete_subscriber_details($subscriber_user_id, $group_details)
	{
		if($this->isItOperation()) {
	        if ($this->_isDebugEnabled()) {
	            $this->_debug("INSUFFICIENT PERMISSIONS");
            }
            return $this->_build_error_message ( ApiResponseConstant::IT_OPERATIONS_PERMISSION_RULE, "" );
        }
		$individualProv = new models\external\prov\Individual ();
		$call_executed_list = array();
		$group_domain = $this->_get_domain_name($group_details);

		$connection = DbConnector::getConnection ();
		$subscriber_details = $this->_get_subscriber_details ( $connection, $subscriber_user_id, $group_details, true );
        $siteServiceInformation = SiteDao::get_site_service_detail_for_prov (
             $connection,
             $group_details->group_id,
             $subscriber_details ["site_identifier"]
            );

		if (is_array ( $subscriber_details ) && array_key_exists ( "ERROR_CODE", $subscriber_details )) {
			return $subscriber_details;
		}
		$subscriber_type = $subscriber_details ["subscriber_type"];
		if (UtilityMethods::isNotEqual ( $subscriber_details ["status"], ProvisioningConstant::SUBSCRIBER_STATUS_ACTIVE )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Status is Not Active for user Id..." . $subscriber_user_id );
			}
			return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_IS_NOT_ACTIVE, "" );
		}

		try {
			if (ProvUtility::isSubscriberConfiguredOrSipTrunk ( $subscriber_type )) {
				if (ProvUtility::isSubscriberConfigured ( $subscriber_type )) {
					$unistim_provision_response = $this->_process_unistim_device_provisioning ( $connection, $subscriber_details, $group_details, FALSE, NULL );
					if (! $unistim_provision_response) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( 'SUBSCRIBER STATUS FOR ' . $subscriber_details ["user_id"] . ' CHANGED TO LOCKED DUE TO FAILURE OF UNISTIM DEVICE REMOVAL' );
						}
						SubscriberDao::lockSubscriber ( $connection, $subscriber_details ["subscriber_id"], $subscriber_details ["group_id"], "UNISTIM_REMOVAL_FAILED" );
						return $this->_build_error_message ( ApiResponseConstant::UNABLE_TO_DELETE_SUBSCRIBER, "" );
					}

					/*
					 * Remove account codes group member
					 */
					try {
						$accountFacade = new AccountCodeFacade ();
						$accountFacade->delete_group_members_from_facade ( $connection, $subscriber_details );
					} catch ( Exception $e ) {
						if ($this->_isErrorEnabled ()) {
							$this->_error ( "Remove Account Code Group Member Failed!", $e );
						}
						throw $e;
					}
				}

				/*
				 * Mark PSTN in progress & Commit.
				 * No need to update vacant list as these no are not part of it.
				 */
				try {
					$connection->beginTransaction ();
					PstndidDao::update_pstndid_in_progress_for_subscriber ( $connection, $subscriber_details ["subscriber_id"] );
					DbConnector::commitTransaction ( $connection );
				} catch ( Exception $e ) {
					DbConnector::rollbackTransaction ( $connection );
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Unable to mark PSTN in progress during Subscriber Creation Failed!", $e );
					}
					throw $e;
				}
			} // end of if(suscriber = Configured)

			//before we start new transaction we need to check if subscriber we need to take care of subscriber who has device buttons provisioned or who is target subscriber for device button
			$device_buttons = $this->delete_device_buttons_provisioned($connection, $group_details, $subscriber_details);
			$call_executed_list[] = "removedButtons";
			$soft_keys = $this->delete_softkeys_provisioned($connection, $group_details, $subscriber_details);
			$call_executed_list[] = "removedSoftKeys";

			$connection->beginTransaction ();

			// Delete authorization code if exists
            $ctbsFacade = new CTBSFacade();
            $removeAuthCodeResponse = $ctbsFacade->removeSubscriberAuthCode($subscriber_user_id);
            if (empty($removeAuthCodeResponse['ERROR_CODE'])) {
                $call_executed_list[] = "removedAuthorizationCode";
            }
			if (UtilityMethods::is_livesupport_service_bundle ( $subscriber_details ["service_set_value"], false ) ) {
				// If user unsubscribed from KANDY need to remove KANDY user.
if (!SITE_LIVE_SUPPORT_DISABLED) {
				$livesupportfacade = new LiveSupportFacade();
				$ls_subscriber_details = $subscriber_details;
				$ls_subscriber_details['user_id'] = substr($subscriber_details['user_id'], 0, strpos($subscriber_details['user_id'], "@"));
				$delete_agent = $livesupportfacade->delete_agent($ls_subscriber_details, $group_details);
				if (array_key_exists ( "ERROR_CODE",$delete_agent )) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Unable to remove Live Support agent." );
					}
					$this->_check_translated_response ( $delete_agent, ApiResponseConstant::LIVE_SUPPORT_DELETE_AGENT_FAILED );
				}
				$call_executed_list[] = "deleteLiveSupportAgent";
}
				$ls_version = LiveSupportDao::get_company_details_by_group_id($connection, $group_details->group_id, "live_support_version");
				if (UtilityMethods::isEqual($ls_version, ProvisioningConstant::LIVE_SUPPORT_KBS_VERSION)) {
					if (!UtilityMethods::isEqual ( $group_details->voice_mail_device_type, ProvisioningConstant::PROVISION_DEVICE_TYPE_IMM )) {
						//Remove CIM group
						$group_details->cim_group_identifier = $group_details->group_identifier;
						$group_details->member_group_identifier = "ls" .$group_details->group_identifier;
						$remove_member_group =  $individualProv->removeGroupMember($connection, $group_details, $subscriber_details);
						if (UtilityMethods::isNotEqual ( $remove_member_group [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isErrorEnabled ()) {
								$this->_error ( "Unable to remove CIM Member group from Subscriber." );
							}
							$this->_check_translated_response ( $remove_member_group, ApiResponseConstant::LIVE_SUPPORT_DELETE_AGENT_FAILED );
						}
						$call_executed_list[] = "deleteGroupMember";
						//Remove CIM rich messaging account
						$delete_cim =  $individualProv->deleterRichMessagingAccount($connection, $group_details, $subscriber_details);
						if (UtilityMethods::isNotEqual ( $delete_cim [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isErrorEnabled ()) {
								$this->_error ( "Unable to remove rich messaging account." );
							}
							$this->_check_translated_response ( $delete_cim, ApiResponseConstant::LIVE_SUPPORT_DELETE_AGENT_FAILED );
						}
						$call_executed_list[] = "deleteRichMessagingAccount";
					}else if (UtilityMethods::isEqual ( $group_details->voice_mail_device_type, ProvisioningConstant::PROVISION_DEVICE_TYPE_IMM )) {
						$group_details->cim_group_identifier = "ls" .$group_details->group_identifier;
						$delete_cim =  $individualProv->deleterRichMessagingAccount($connection, $group_details, $subscriber_details);
						if (UtilityMethods::isNotEqual ( $delete_cim [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isErrorEnabled ()) {
								$this->_error ( "Unable to remove rich messaging account." );
							}
							$this->_check_translated_response ( $delete_cim, ApiResponseConstant::LIVE_SUPPORT_DELETE_AGENT_FAILED );
						}
						$call_executed_list[] = "deleteRichMessagingAccount";
					}

                    // Retrieve subscriber on SPiDR
                    $spidrSubscriber = $this->getSpidrSubscriber($connection, $group_details, $subscriber_details);
                    if ($spidrSubscriber) {
                        $spidrResponse = $this->deleteSpidrSubscriber(
                            $connection,
                            $group_details,
                            $subscriber_details,
                            Spider::TYPE_NUVIA
                        );

                        if (!$spidrResponse) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error('Unable to remove subscriber from SPiDR.');
                            }
                            $this->_check_translated_response(
                                $spidrResponse,
                                ApiResponseConstant::LIVE_SUPPORT_DELETE_AGENT_FAILED
                            );
                        }
                    }
                    $call_executed_list[] = 'deleteSpidrSubscriber';
				}
 //delete  anonymous user
                $this->_debug(' LiveSupportFacade -> delete_subscriber_details - Delete anon users ');
                $lsFacade = new livesupportfacade();
                for ($i = 0; $i < 3; $i++) {
                    $lsFacade->delete_anon_users($group_details);
                }
			}

			if (ProvUtility::isDefaultStatusActive ( $subscriber_details ["default_status"] )) {
				SubscriberDao::insert_subscriber_invoice_details ( $connection, $subscriber_details, ReportConstant::SUBSCRIBER_INVOICE_REMOVED_STATUS, $group_domain, ProvUtility::getPstnDidGroupId ( $group_details ) );
			}
			if (ProvUtility::isSubscriberConfiguredOrSipTrunk ( $subscriber_type )) {
				$pstn_vacant_userid_array = PstndidDao::get_vacant_user_id_from_subscriber ( $connection, $subscriber_details ["subscriber_id"] );
				PstndidDao::removeAllPSTNDidForSubscriber($connection, $subscriber_details['subscriber_id'], $subscriber_type);
				if (ProvUtility::isSubscriberConfigured ( $subscriber_type )) {
                    //remove assignment of mac to subscriber
                    TerminalsDao::removeMacAddressForSubscriber($connection, $subscriber_details["subscriber_id"]);
					GenericDeviceDao::remove_mac_addr_for_subscriber ( $connection, $subscriber_details ["subscriber_id"] );
				}
			} // end of if(subscriber = Configured)

            if (ProvUtility::isTypeStandaloneAndServiceSetMsTeams($subscriber_details)) {
                $provisioningMSTeamsSubscriber = new ProvisioningMSTeamsSubscriber($connection, $group_details, $subscriber_details);
                $msResponse = $provisioningMSTeamsSubscriber->deleteMsTeamsSubscriber();
                if (is_array($msResponse) && array_key_exists('ERROR_CODE', $msResponse)) {
                    return $msResponse;
                }
                $pstnVacantUseridArray = PstndidDao::get_vacant_user_id_from_subscriber($connection, $subscriber_details["subscriber_id"]);
                PstndidDao::removeAllPSTNDidForSubscriber($connection, $subscriber_details['subscriber_id'], $subscriber_type);
                if (VACANT_NUMBER_NEW_A2_SERVICE) {
                    $this->addDIDFromVacantList(
                        $connection,
                        ProvUtility::getPstnDidDomain($connection, $group_details),
                        ProvUtility::getPstnDidGroupId($group_details),
                        $subscriber_details['voip_numbers']
                    );
                } else {
                    $this->updateVacentPstndidNumbers(
                        $connection,
                        ProvUtility::getPstnDidDomain($connection, $group_details),
                        ProvUtility::getPstnDidGroupId($group_details),
                        $pstnVacantUseridArray
                    );
                }
                SubscriberAddressDao::removeBySubscriberId($connection, $subscriber_details['subscriber_id']);
            }

            if (ProvUtility::isTypeStandaloneAndServiceSetImmLs($subscriber_details)) {
                PstndidDao::removeAllPSTNDidForSubscriber($connection, $subscriber_details['subscriber_id'], $subscriber_type);
            }

			if (ProvUtility::isSubscriberConfigured ( $subscriber_type )) {
				// Remove any sla group which is associalted with this subscriber
				$sla_group = CallRoutingDao::get_sla_group_details_by_primary_account ( $connection, $group_details->group_id, $subscriber_details ["user_id"] );
				if (! empty ( $sla_group )) {
					$call_routing_facade = new CallRoutingFacade ();
					$sla_agents = $call_routing_facade->get_sla_agent ( $connection, $group_details, $subscriber_details ["user_id"] );
					SubscriberDao::update_call_group_count ( $connection, $group_details->group_id, $sla_agents, false );
					CallRoutingDao::delete_sla_group_by_primary_account ( $connection, $group_details->group_id, $subscriber_details ["user_id"] );
                }
            }

            if (UtilityMethods::isNotEmpty($subscriber_details['sso_auth_user_id'])) {
                $ssoFacade = new SsoFacade();
                $deleteKeycloakSubscriberResponse = $ssoFacade->deleteKeycloakUser($connection, $group_details,
                    $subscriber_details, SsoConstant::SUBSCRIBER_SSO);
                $call_executed_list[] = 'deleteKeycloakSubscriber';
            }

			if (ContactCenterPeopleDao::check_people_exist ( $connection, $subscriber_details ["user_id"], $group_details->group_id ) > 0) {
				$campaign_number = ContactCenterPeopleDao::get_campaign_number_subscriber_id ( $connection, $group_details->group_id, $subscriber_details ["subscriber_id"] );
				ContactCenterPeopleDao::delete_people_by_subscriber ( $connection, $subscriber_details ["subscriber_id"], $group_details->group_id );
			}
			if($subscriber_details["service_access_status"] == ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_INACTIVE){
				SubscriberDao::update_suspend_subscriber_log_with_active_date($connection, $subscriber_details["user_id"]);
			}
			SubscriberDao::delete_subscriber ( $connection, $subscriber_details ["subscriber_id"], $group_details->group_id );
			$this->_add_remove__subscriber_notices ( $connection, $group_details->group_id );

			$call_executed_list = array ();

			// Remove campaign number in A2
			if (isset ( $subscriber_details ["campaign_number"] ) && UtilityMethods::isNotEqual ( $subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
				$campaignnumber = new models\external\prov\CampaignNumber ();
				$response = $campaignnumber->removeCampaignNumber ( $connection, $subscriber_details );
				if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> removeCampaignNumber failed  for user " . $subscriber_details ['user_id'] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					}
					DbConnector::rollbackTransaction ( $connection );
					return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_DELETE_REMOVE_CAMPAIGN_NUMBER_CALL_FAILED );
				}
				$call_executed_list [] = "removeCampaignNumber";
			}

			if (ProvUtility::isSubscriberConfiguredOrStandalone ( $subscriber_type ) || UtilityMethods::is_sip_pbx_routing_menu_bundle ( $subscriber_details ["menu"] ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $subscriber_details ["menu"] )) {
				$this->_deleteSubscriber($connection, $group_details, $subscriber_details, $individualProv, $call_executed_list);
			} // end of (subscriber = Configured OR Standalone)

            if (UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($subscriber_details['service_set_value'])) {
                $this->_delete_call_recording_user($connection, $group_details, $subscriber_details, $call_executed_list);
            }
            if (UtilityMethods::isSoForSfdcSubscriberBundle($subscriber_details['service_set_value'])) {
                $sfdcFacade = new SfdcFacade();
                $deleteResponse = $sfdcFacade->deleteSubscriber(
                    $connection,
                    $subscriber_details['user_id'],
                    $subscriber_details['settings']['sfdc_email'],
                    $subscriber_details ['voip_numbers'],
                    $subscriber_details['voip_alias']
                );
                if (array_key_exists('ERROR_CODE', $deleteResponse)) {
                    return $this->_build_error_message(
                        ApiResponseConstant::SUBSCRIBER_MSISDN_REMOVE_SUBSCRIBER_FAILED, ""
                    );
                }
                $sfdcFacade->sendSfdcEmailNotification("Delete", $group_details, $subscriber_details, "");
            }
			  // Update A2 with the PSTN number used by user as Vacant
            if (ProvUtility::isSubscriberConfiguredOrSipTrunk($subscriber_type)) {
                if (VACANT_NUMBER_NEW_A2_SERVICE) {
                    $this->addDIDFromVacantList(
                        $connection,
                        ProvUtility::getPstnDidDomain($connection, $group_details),
                        ProvUtility::getPstnDidGroupId($group_details),
                        $subscriber_details['voip_numbers']
                    );
                } else {
                    $this->updateVacentPstndidNumbers(
                        $connection,
                        ProvUtility::getPstnDidDomain($connection, $group_details),
                        ProvUtility::getPstnDidGroupId($group_details),
                        $pstn_vacant_userid_array
                    );
                }
            }

			/* Update Business Continuity Order Status Starts */
			if (UtilityMethods::is_bcpremium_bundle ( $subscriber_details ["service_set_value"] )) {
				$this->remove_subscriber_business_continuity_status ( $connection, $group_details->group_id, 1 );
			}
			/* Update Business Continuity Order Status Ends */

			/* Delete if this subscriber is test client */
			$test_subscriber = ClientBrandingDao::get_all_test_subscriber($connection, $subscriber_user_id, $group_details->group_id);
			if($test_subscriber)
				ClientBrandingDao::delete_all_subscriber_test($connection, $subscriber_user_id, $group_details->group_id);

			// ACL 1388 Account Turn up Cache
			if (ProvUtility::isDefaultStatusActive ( $subscriber_details ["default_status"] )) {
				$sync_invoice_process = new SyncInvoiceProcessFacade ();
				$sync_invoice_process->invoke_sync_invoice_process ( $connection, SyncInvoiceConstant::SYNC_INVOICE_TASK_TYPE_SUBSCRIBER, $group_details->group_id );
			}

			// Remove Kandy user.
			if (UtilityMethods::is_kandy_msisdn_bundle ( $subscriber_details ["service_set_value"] )) {
				if (! $this->_delete_kandy_subscriber ( $connection, $group_details, $subscriber_details )) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Unable to remove Kandy user." );
					}
					return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_MSISDN_REMOVE_SUBSCRIBER_FAILED, "" );
				}
                $call_executed_list[] = 'removeKandyUser';
			}

			// Remove subscriber with multimedia office sku
			if (UtilityMethods::is_omniclient_service_bundle ( $subscriber_details ["service_set_value"] )) {
                $spidrSubscriber = $this->getSpidrSubscriber($connection, $group_details, $subscriber_details);
                if ($spidrSubscriber) {
                    $spidrResponse = $this->deleteSpidrSubscriber(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        Spider::TYPE_NUVIA
                    );
                    if (!$spidrResponse) {
                        $this->_error('Unable to delete Spidr account.');
                        throw new CallFailedException('', ApiResponseConstant::SUBSCRIBER_MSISDN_REMOVE_SUBSCRIBER_FAILED);
                    }
                    $call_executed_list[] = 'deleteSpidrSubscriber';
                }
			}

            if ($this->_isApiConsumerOrApiCallMeServiceBundle($subscriber_details['service_set_value'])) {
                $spidrSubscriber = $this->getSpidrSubscriber($connection, $group_details, $subscriber_details);
                if ($spidrSubscriber) {
                    $spidrResponse = $this->deleteSpidrSubscriber(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        Spider::TYPE_NUVIA
                    );

                    if (!$spidrResponse) {
                        if ($this->_isErrorEnabled()) {
                            $this->_error('Unable to remove API consumer user.');
                        }
                        return $this->_build_error_message(
                            ApiResponseConstant::SUBSCRIBER_MSISDN_REMOVE_SUBSCRIBER_FAILED,
                            $spidrResponse
                        );
                    }
                    $call_executed_list[] = 'deleteSpidrSubscriber';
                }

                if (UtilityMethods::is_VoIP_number_not_empty($subscriber_details['voip_numbers'])) {
                    $PSTNDid = $subscriber_details['voip_numbers'];
                } else {
                    $PSTNDid = PstndidDao::get_primary_pstn_did($connection, $subscriber_details['user_id']);
                }

                // Check the service set is KBS_APICALLME or KBS_APICALLME_PSTN
                if (
                    !UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle(
                        $subscriber_details['service_set_value']
                    )
                ) {
                    // Check the KBS_APICONSUMER, KBS_APICALLME and KBS_APICALLME_PSTN service sets
                    if (!UtilityMethods::is_kbs_api_consumer_service_bundle($subscriber_details ['service_set_value'])
                        || (UtilityMethods::is_kbs_api_consumer_service_bundle($subscriber_details ['service_set_value'])
                            && UtilityMethods::isNotEmpty($PSTNDid))) {

                        $subscriberDetailsSMS = $subscriber_details;
                        $userID = $subscriber_details['user_id'];
                        $userIDPosition = strpos($userID, '@');
                        $subscriberDetailsSMS['voicemail_account'] = substr($userID, 0, $userIDPosition);

                        $individualProv->deleteSMSAccount($connection, $group_details, $subscriberDetailsSMS);
                    }
                }

            }

			//Delete Mida User
            $subscriber_details['mida_user_id'] = MidaUserDao::get_mida_user_id_by_user_id($connection,$subscriber_details ['user_id']);
			if(!empty($subscriber_details['mida_user_id'])){
				$connection = DbConnector::getConnection();
				$prov_system_id = $subscriber_details ["prov_system_id"];
	            $extension_id = MidaUserDao::get_extension_id_by_user_id($connection, $subscriber_details ['user_id']);
	            $mida_facade = new MidaFacade;
	            $mida_facade->delete_mida_user($connection, $subscriber_details, $prov_system_id, $extension_id);
			}

            // START - delete live support inbound voice provisioning.
            if (UtilityMethods::isLiveSupportInboundVoiceMenuBundle($subscriber_details['menu'])) {
                $this->deleteLiveSupportInboundVoiceProvisioning(
                    $connection,
                    $subscriber_details,
                    $group_details,
                    $call_executed_list
                );
            }
            // END - delete live support inbound voice provisioning.

            // Delete voip numbers from PSX
            $psxFacade = new PSXFacade();
            $psxFacade->deleteFromPSX($subscriber_details['voip_numbers'], $group_details->group_id);
            if (!empty($subscriber_details['public_charge_id'])) {
                $psxFacade->deletePSXNumber($group_details->group_id, $subscriber_details['public_charge_id']);
            }
            $psxFacade->deleteFromPSX($subscriber_details ['voip_numbers'], $group_details->group_id);

            AADirectorySyncFacade::factory($connection)->syncSubscriberDetails(null, $subscriber_details);

			DbConnector::commitTransaction($connection);

			//for subscriber report
			$user_id = preg_split('/@/', $subscriber_user_id)[0];
			$res_status = SubscriberDao::get_restricted_status($connection, $user_id);
			if ($res_status) {
				$subscriber_details['service_access_status'] = strtoupper(ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_DISPLAY_CONTENT_RESTRICTED);
			}

			// START - Report for Subscriber provisioning changes.
            $this->subscriber_historic_report(ReportConstants::EVENT_TYPE_DELETE, $group_details, $subscriber_details);
            // END - Report for Subscriber provisioning changes.

            if ($this->_isDebugEnabled()) {
                $this->_debug('Subscriber ' . $subscriber_user_id . ' deleted successfully...');
            }

		} catch ( Exception $e ) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Delete subscriber Failed!", $e );
			}
			DbConnector::rollbackTransaction ( $connection );
			/*
			 * Cancel PSTN Did that was marked as in progress
			 * No need to update vacant list as these no are not part of it.
			 */

			if (in_array('_deleteUser', $call_executed_list)) {
                $response = $individualProv->addUser(
                    $connection,
                    $group_details,
                    $subscriber_details,
                    $siteServiceInformation,
                    true
                );
                if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Subscriber could not be added to A2 again.", $response );
					}
                }
            }

            if (in_array('removedAuthorizationCode', $call_executed_list)) {
                $ctbsFacade = new CTBSFacade();
                $ctbsFacade->setSubscriberAuthCode($subscriber_details['user_id'], $subscriber_details['settings']['authorization_code']);
            }

            if (in_array('findAndDeleteVoicemail', $call_executed_list)) {
                $individualProv->createVoicemail($connection, $group_details, $subscriber_details);
            }

            if (in_array('deleteRichMessagingAccount', $call_executed_list)) {
                $servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR . '|' . ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                $individualProv->createRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
            }

			if (UtilityMethods::isEqual ( $subscriber_type, ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED )) {
				try {
					$connection->beginTransaction ();
					PstndidDao::reset_pstndid_in_progress_for_subscriber ( $connection, $subscriber_details ["subscriber_id"] );
					DbConnector::commitTransaction ( $connection );
				} catch ( Exception $e ) {
					DbConnector::rollbackTransaction ( $connection );
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "updating reset Vacant number Failed!", $e );
					}
				}
			}
			if (in_array("removedButtons", $call_executed_list)) {
				if(!empty($device_buttons) && !empty($device_buttons['buttons_removed'])){
					error_log(print_r("Trigger Rollback for device buttons, reading the following buttons back to subscriber ->".$subscriber_details ["subscriber_id"]." : ", TRUE).PHP_EOL);
					error_log(print_r($device_buttons, TRUE).PHP_EOL);
    				foreach ($device_buttons['buttons_removed'] as $key => $value) {
    					$device_buttons_facade = new DeviceButtonFacade();
    					foreach ($value['old_device_buttons_provisioning'] as $kem_key => $old_device_buttons) {
    						$device_buttons_facade -> _rollback_add($connection, $value['sbp_details_old'][$kem_key], $old_device_buttons, $group_details->group_id, $key);
    					}
    					$device_buttons_facade->_rollback_add_kem($key, reset($value['old_device_buttons_provisioning']));
    					// $device_buttons_facade -> _rollback_add($connection,$value['sbp_details_old'], $value['old_device_buttons_provisioning'], $group_details->group_id, $key);
    				}
    			}
			}
			if (in_array("removedSoftKeys", $call_executed_list)) {
			    if(!empty($soft_keys) && !empty($soft_keys['old_soft_key_details'])){
			        error_log(print_r("Trigger Rollback for softkeys, reading the following keys back to subscriber ->".$subscriber_details ["subscriber_id"]." : ", TRUE).PHP_EOL);
			        error_log(print_r($device_buttons, TRUE).PHP_EOL);
			    		if(isset($soft_keys['old_soft_key_details'])){
			    		    foreach($soft_keys['old_soft_key_details'] as $old){
			    		        $device_buttons_facade -> _rollback_save_softkey($connection,$soft_keys['old_soft_key_details'], $group_details->group_id, $soft_keys['old_soft_key_details']['mac_address']);
			    		    }
			    		}
			    }
			}
			// Roll back remove campaign Number
			if (in_array ( "removeCampaignNumber", $call_executed_list )) {
                $campaignnumber_prov = new models\external\prov\CampaignNumber ();
                $people_details = SubscriberDao::get_subscriber_details_for_campaign_number($connection, $subscriber_details['group_id'], $subscriber_details['subscriber_id']);
                $people_details['campaign_number'] = ContactCenterPeopleDao::get_campaign_number_subscriber_id($connection, $subscriber_details['group_id'], $subscriber_details['subscriber_id']);
                $campaignnumber->addCampaignNumber($connection, $people_details);
            }

            if (in_array('deleteSpidrSubscriber', $call_executed_list)) {
                $this->createSpidrSubscriber(
                    $connection,
                    $group_details,
                    $subscriber_details,
                    $call_executed_list,
                    Spider::TYPE_NUVIA
                );
            }

            if (in_array('_delete_call_recording_user => deleteUser', $call_executed_list)) {
                $this->_add_call_recording_user(
                    $connection,
                    $subscriber_details['service_set_value'],
                    $subscriber_details,
                    $call_executed_list
                );
                (in_array('_add_call_recording_user => addUser', $call_executed_list))
                ? $this->_debug('The rollback from Orecx is complete.')
                : $this->_debug('The rollback from Orecx failed.');
            }

			if (in_array("deleteGroupMember", $call_executed_list)) {
				$individualProv->addGroupMember($connection, $group_details, $subscriber_details);
			}
			if (in_array("deleteLiveSupportAgent", $call_executed_list)) {
				$livesupportFace = new LiveSupportFacade();
				$livesupportfacade->create_agent($connection, $subscriber_details, $group_details);
			}
			if (in_array("removeKandyUser", $call_executed_list)) {
				$this->_provision_kandy_subscriber($connection, $group_details, $subscriber_details, $response);
			}

			if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
				if (UtilityMethods::isEqual ( $e->getCode (), ApiResponseConstant::SUBSCRIBER_DELETE_USER_CALL_FAILED )) {
					return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_DELETE_DELETE_USER_CALL_FAILED, "" );
				}
				if (UtilityMethods::isEqual ( $e->getCode (), ApiResponseConstant::SUBSCRIBER_FIND_AND_DELETE_VOICEMAIL_CALL_FAILED )) {
					return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_DELETE_FIND_AND_DELETE_VOICEMAIL_CALL_FAILED, "" );
				}
				if (UtilityMethods::isEqual ( $e->getCode (), ApiResponseConstant::SUBSCRIBER_REMOVE_USER_VOICEMAIL_SERVER_CALL_FAILED )) {
					return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_DELETE_REMOVE_USER_VOICEMAIL_SERVER_CALL_FAILED, "" );
				}
				if (UtilityMethods::isEqual ( $e->getCode (), ApiResponseConstant::SUBSCRIBER_REMOVE_SO_VIDEO_CALL_FAILED )) {
					return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_DELETE_REMOVE_USER_SO_VIDEO_CALL_FAILED, "" );
				}
				if (UtilityMethods::isEqual ( $e->getCode (), ApiResponseConstant::SUBSCRIBER_REMOVE_SO_WEB_CALL_FAILED )) {
					return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_DELETE_REMOVE_USER_SO_WEB_CALL_FAILED, "" );
				}
				return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
			}
			return $this->_build_error_message ( ApiResponseConstant::UNABLE_TO_DELETE_SUBSCRIBER, "" );
		}
	}

	// end of method delete_subscriber_details()
	public function update_subscriber_details($update_user_id, $param_array, $group_details, $individual = false) {
		$response_array = array ();
		$connection = DbConnector::getConnection ();
        if (ResetDao::checkSubscriberToUpdate($connection, $update_user_id)) {
            $this->_error("Subscriber is in progress for reset action. Updating action cannot be taken at this time. "
                . "Subscriber: " . $update_user_id);
            return $this->_build_error_message(ApiResponseConstant::RESET_API_SUBSCRIBER_IN_RESET_QUEUE, "");
        }
		$old_subscriber_details = $this->_get_subscriber_details ( $connection, $update_user_id, $group_details, true );
        unset($old_subscriber_details['public_charge_id']);
        $current_user_language = UtilityMethods::get_current_user_language();
		$current_login_user_language = CommonConstant::LANGUAGE_ENGLISH_VALUE;
		switch ($current_user_language) {
			case GroupConstant::LANGUAGE_PREFERENCE_FRENCH:
				$current_login_user_language = CommonConstant::LANGUAGE_FRENCH_VALUE;
				break;
			default:
				$current_login_user_language = CommonConstant::LANGUAGE_ENGLISH_VALUE;
		}
		$other_error_message = [];
		include ERROR_MSG_PATH.'other_error_message_'.$current_login_user_language.'.php';
		$this->_other_error_message = $other_error_message;
		if (UtilityMethods::isAPIVersionGreaterThan3_28 () && isset ( $old_subscriber_details ["ERROR_CODE"] )) { // Invalid Subscriber User Id
			return $old_subscriber_details;
		}

		if (UtilityMethods::isAPIVersionGreaterThan3_28 () && UtilityMethods::isNotEqual ( $old_subscriber_details ["status"], ProvisioningConstant::SUBSCRIBER_STATUS_ACTIVE )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Status is Not Active for user Id..." . $old_subscriber_details ["user_id"] );
			}
			return SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_IS_NOT_ACTIVE, null );
		}

        if (isset($param_array["settings"]["email"])) {
            // This is for multi-email support in DB and CIM. Getting first email for other systems.
            $param_array["settings"]["emails"] = $param_array["settings"]["email"];
            $param_array["settings"]["email"] = trim(explode(",", $param_array["settings"]["email"])[0]);
        }

		$subscriber_details = $this->_flatten_parameter ( $param_array );

        if (isset($subscriber_details['is_ls_request']) && !empty($subscriber_details['is_ls_request'])) {
            $old_subscriber_details['is_ls_request'] = $subscriber_details['is_ls_request'];
        }

		if(!UtilityMethods::isApi() && !array_key_exists('role', $subscriber_details)){
		   $subscriber_details['role'] = '';
        }

        if (!UtilityMethods::isApi() && !array_key_exists('department', $subscriber_details)) {
            $subscriber_details['department'] = '';
        }

        if (isset($subscriber_details['sso_auth_user_id']) && !empty($subscriber_details['sso_auth_user_id'])) {
            $subscriber_details['sso_auth_user_id'] = strtolower($subscriber_details['sso_auth_user_id']);
        }

		if(!UtilityMethods::isApi() && !array_key_exists('sso_auth_user_id', $subscriber_details)) {
			$subscriber_details['sso_auth_user_id'] = '';
		}
        $psx = new PSXFacade();
        if (
            $psx->isPSXEnabled($group_details->group_id)
            && empty($subscriber_details['selected_voip_numbers_array'])
            && empty($subscriber_details['public_charge_id'])
            && !empty($subscriber_details['menu'])
            && !UtilityMethods::is_standalone_voicemail_menu_bundle($subscriber_details['menu'])
        ) {
            return ['ERROR_CODE' => ApiResponseConstant::PSX_PUBLIC_CHARGE_ID_IS_REQUIRED];
        }

        if (
            !empty($subscriber_details['authorization_code'])
            && !CTBSDao::getAuthorizationCodesByGroupIdAndValue($connection, $group_details->group_id, $subscriber_details['authorization_code'])
        ) {
            return ['ERROR_CODE' => ApiResponseConstant::AUTHORIZATION_CODE_IS_NOT_RESERVED_FOR_CUSTOMER];
        }

        if (
            !empty($subscriber_details['public_charge_id'])
            && $psx->isPSXEnabled($group_details->group_id)
            && UtilityMethods::isNotEqual($subscriber_details['public_charge_id'][0], PSXConstant::E164_NUMBER_PREFIX)
        ) {
            $subscriber_details['public_charge_id'] = PSXConstant::E164_NUMBER_PREFIX . $subscriber_details['public_charge_id'];
        }

        if (UtilityMethods::isApi()) {
            // If there is no sso_auth_user_id on request, check old sso_auth_user_id
            if (!array_key_exists('sso_auth_user_id', $subscriber_details)) {
                if (UtilityMethods::isNotEmpty($old_subscriber_details['sso_auth_user_id'])) {
                    $subscriber_details['sso_auth_user_id'] = $old_subscriber_details['sso_auth_user_id'];
                } else {
                    $subscriber_details['sso_auth_user_id'] = '';
                }
            }

            // Throw error message if sso_auth_user_id is empty and authentication_method is SSO
            if ((UtilityMethods::isEqual($subscriber_details['authentication_method'],
                        SubscriberConstant::AUTHENTICATION_METHOD_SSO)
                    || UtilityMethods::isEqual($old_subscriber_details['authentication_method'],
                        SubscriberConstant::AUTHENTICATION_METHOD_SSO))
                && $subscriber_details['sso_auth_user_id'] === '') {

                $response['ERROR_CODE'] = ApiResponseConstant::CANNOT_EMPTY_AUTH_USER_ID;
                return $response;
            }
        }

        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])
            && UtilityMethods::isNotEmpty($old_subscriber_details['authentication_method'])){
            $subscriber_details['authentication_method'] = $old_subscriber_details['authentication_method'];
        }
		// Default auth method is SSO when Only Single Sign On
        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])
            && UtilityMethods::isEqual($group_details->is_sso_enabled_subscriber,SsoConstant::MANDATORY_SSO_ENUM)) {
            $subscriber_details['authentication_method'] = SubscriberConstant::AUTHENTICATION_METHOD_SSO;
        }

        // Default auth method is BASIC when Only Username Password
        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])
            && UtilityMethods::isNotEqual($group_details->is_sso_enabled_subscriber,
            SsoConstant::MANDATORY_SSO_ENUM)) {
            $subscriber_details['authentication_method'] = SubscriberConstant::AUTHENTICATION_METHOD_BASIC;
        }
        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])) {
            $subscriber_details['authentication_method'] = SubscriberConstant::AUTHENTICATION_METHOD_BASIC;
        }
        $ssoFacade = new SsoFacade();
        // authentication_method Checks Start
        $validationForAuthMethod = $ssoFacade->validateSubscriberAuthMethod(
                $subscriber_details['authentication_method'],
                $group_details->is_sso_enabled_subscriber,
                $subscriber_details['products_details']
            );
        if ($validationForAuthMethod['error']) {
            $response_array['ERROR_CODE'] = $validationForAuthMethod['error'];
            return $response_array;
        }
        if (UtilityMethods::isEmpty($subscriber_details['authentication_method'])) {
            $subscriber_details['authentication_method'] = '';
        }
        // authentication_method Checks End

        // authUserId Checks START
        //"Subscriber authentication_method is SSO" or "Old Subscriber is SSO when authentication_method null"
        $isSubscriberAuthMethodSSO = UtilityMethods::isEqual($subscriber_details['authentication_method'],
            SubscriberConstant::AUTHENTICATION_METHOD_SSO)
            || (UtilityMethods::isEmpty($subscriber_details['authentication_method'])
                && UtilityMethods::isEqual($old_subscriber_details['authentication_method'],
                    SubscriberConstant::AUTHENTICATION_METHOD_SSO));
        $isChangedAuthID = UtilityMethods::isNotEqual(
            $subscriber_details['sso_auth_user_id'],
            $old_subscriber_details['sso_auth_user_id']
        );
        $isOldSubscriberAuthIdEmpty = UtilityMethods::isEmpty($old_subscriber_details['sso_auth_user_id']);

        if ($isChangedAuthID || $isOldSubscriberAuthIdEmpty) {

            if (UtilityMethods::isEmpty($subscriber_details['products_details'])) {
                $subscriber_details['products_details'] = [];
            }

            if (UtilityMethods::isEmpty($old_subscriber_details['products_details'])) {
                $old_subscriber_details['products_details'] = [];
            }

            $currentlyProductList = array_merge(
                $subscriber_details['products_details'],
                $old_subscriber_details['products_details']
            );

            $authUserIdValidation = [];
            if ($subscriber_details['sso_auth_user_id']) {
                $authUserIdValidation = $ssoFacade->validateSubscriberAuthUserId(
                    $group_details->group_id,
                    $subscriber_details['sso_auth_user_id'],
                    $subscriber_details['user_id'],
                    $currentlyProductList,
                    $subscriber_details['authentication_method']
                );
            }

            if (isset($authUserIdValidation['error']) && !empty($authUserIdValidation['error'])) {
                $response_array['ERROR_CODE'] = $authUserIdValidation['error'];
                return $response_array;
            }

            if (!isset($authUserIdValidation['sso_enabled']) && empty($authUserIdValidation['sso_enabled'])) {
                $subscriber_details['sso_auth_user_id'] = '';
            }
        }

        if ($isSubscriberAuthMethodSSO) {
            $isSsoSubscriberExist = $this->syncKeycloakSubscriber($old_subscriber_details, $group_details);
            if (isset($isSsoSubscriberExist['ERROR_CODE'])) {
                $ssoFacade->createKeycloakUser($connection, $group_details, $subscriber_details, SsoConstant::SUBSCRIBER_SSO);
                $ssoFacade->loggingKeycloak($subscriber_details['sso_auth_user_id'] . " --> Subscriber created again on Keycloak");
            }
        }
        // authUserId Checks END

        if (in_array(constant('SubscriberConstant::SFDC_BUNDLE'), $subscriber_details['products_details'])) {
            $validate = SubscriberValidator::validateSfdc($subscriber_details, CommonConstant::ACTION_TYPE_EDIT);
            if (!empty($validate['validation_errors'])) {
                if (empty($subscriber_details['sfdc_email'])) {
                    $responseSfdc['ERROR_CODE'] = ApiResponseConstant::SFDC_MAIL_REQUIRED_CHECK;
                    return $responseSfdc;
                }
                $responseSfdc['ERROR_CODE'] = ApiResponseConstant::SFDC_MAIL_FORMAT_INVALID;
                return $responseSfdc;
            } elseif (isset($subscriber_details['voip_numbers'])
                && !UtilityMethods::is_VoIP_number_not_empty($subscriber_details['voip_numbers'])) {
                $responseVoip ['ERROR_CODE'] = ApiResponseConstant::VOIP_NUMBER_REQUIRED_FOR_SFDC_USER;
                return $responseVoip;
            }
        }

		$product_details = true;
		if (! isset ( $old_subscriber_details ["ERROR_CODE"] )) {
			if($this->isItOperation()){
				$is_restricted = false;
				//products
				$product_diff = $this->_get_array_difference ($old_subscriber_details["products_details"], $subscriber_details["products_details"], FALSE);
				if(count($product_diff['ADDED_ITEMS']) > 0 || count($product_diff['REMOVED_ITEMS']) > 0) {
					$is_restricted = true;
				}
				//devices
				$devices_diff = $this->_get_array_difference ($old_subscriber_details ["devices"], preg_replace("/[^A-z0-9]+/", "", $subscriber_details["devices"]), FALSE);
				if(count($devices_diff['ADDED_ITEMS']) > 0 || count($devices_diff['REMOVED_ITEMS']) > 0) {
					$is_restricted = true;
				}
				if($is_restricted == true) {
					$this->_debug("You do not have sufficient permissions");
					return array("ERROR_CODE"=>ApiResponseConstant::IT_OPERATIONS_PERMISSION_RULE);
				}
			}
            if (UtilityMethods::isNotNull($param_array['advanced_settings']['is_eup_advanced_enabled'])) {
                SubscriberDao::update_subscriber_eup_advanced_enabling($connection, ($param_array['advanced_settings']['is_eup_advanced_enabled'] == 'enabled' ? 1 : 0), $old_subscriber_details["subscriber_id"], $old_subscriber_details['group_id']);
            }
			if ($this->_is_field_not_empty ( $subscriber_details, "products_details" )) {
				// validate product and inventory exist
				$old_product_details = explode ( "|", $old_subscriber_details ["sku"] );

				$response_array = $this->_validateProductAndInventory ( $connection, $subscriber_details ["products_details"], $group_details, $old_product_details );
				if (! is_array ( $response_array ) || ! array_key_exists ( "ERROR_CODE", $response_array )) {
					$is_limited = PartnerDao::get_single_result_by_group_id ( $connection, "is_limited", $group_details->parent_group_id );
					if ($is_limited == "1") {
						$grandparent_id = GroupDao::get_grandparent_group_id ( $connection, $group_details->parent_group_id );
						$product_details = ProductDao::getSubscriberProductDetailsForSkus ( $connection, $subscriber_details ["products_details"], $grandparent_id, $group_details->parent_group_id );
					} else {
						$product_details = ProductDao::getSubscriberProductDetailsForSkus ( $connection, $subscriber_details ["products_details"], $group_details->parent_group_id, $group_details->group_id );
					}
					$subscriber_details ["sku"] = $product_details ["skus"];
					$subscriber_details ["product_ids"] = $product_details ["product_ids"];
					$subscriber_details ["service_set_value"] = $product_details ["service_set_values"];
					$subscriber_details ["menu"] = $product_details ["menu"];
				}
			}  // end of if($this->_is_field_not_empty($subscriber_details, "products_details"))
			else {
				$subscriber_details ["menu"] = ProductDao::getSubscriberMenuByServiceSet ( $connection, $old_subscriber_details ["service_set_value"] );
				unset ( $subscriber_details ["products_details"] );
				$subscriber_details ["sku"] = $old_subscriber_details ["sku"];
				$subscriber_details ["product_ids"] = $old_subscriber_details ["product_ids"];
				$subscriber_details ["service_set_value"] = $old_subscriber_details ["service_set_value"];
			} // end of else-if($this->_is_field_not_empty($subscriber_details, "products_details"))
		}
        if (
            !empty($subscriber_details['scheduled_call_restriction'])
            && !empty($subscriber_details["service_set_value"])
            && $subscriber_details['scheduled_call_restriction'] == CommonConstant::ENABLE
            && !UtilityMethods::is_premium_subscriber($subscriber_details["service_set_value"])
        ) {
            return ['ERROR_CODE' => ApiResponseConstant::INSUFFICIENT_INVENTORY];
        }
        if ((UtilityMethods::is_rich_messaging_service_bundle($subscriber_details['service_set_value'])
            && (strlen($subscriber_details['user_id']) > SubscriberConstant::MAX_LENGTH_FOR_SUB_WITH_RICH_MESSAGE_SKU
                || strlen($old_subscriber_details['user_id']) > SubscriberConstant::MAX_LENGTH_FOR_SUB_WITH_RICH_MESSAGE_SKU))
        ) {
            return SubscriberValidator::build_error_message(
                ApiResponseConstant::SIP_USER_ID_LENGTH_LIMITED_FOR_RICH_MESSAGING_SKU_UPDATE, ''
            );
        }

        if (
            (isset($subscriber_details['is_ls_request']) && !empty($subscriber_details['is_ls_request']))
            && !UtilityMethods::is_livesupport_service_bundle($subscriber_details['service_set_value'])
        ) {
            $response_array['ERROR_CODE'] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
            return $response_array;
        }

		if (isset ( $subscriber_details ["user_password"] )) {
			$subscriber_details ["update_password_field"] = true;
			SubscriberDao::delete_session_subscriber_user_portal($connection, $subscriber_details['user_id']);
		}

		if (isset ( $subscriber_details ["device_password"] )) {
			$subscriber_details ["update_device_password_field"] = true;
		}

        if ((UtilityMethods::is_omniclient_service_bundle($subscriber_details ["service_set_value"]) || UtilityMethods::is_omniclient_service_bundle($old_subscriber_details ["service_set_value"]))
            && UtilityMethods::isNotEqual($subscriber_details['fromData'] ?? '', SubscriberConstant::SUBSCRIBER_DATA_FROM_API)) {
			if (! array_key_exists ( 'client_type_id', $subscriber_details )) {
				$subscriber_details ["client_type_id"] = '';
			}
			if (! array_key_exists ( 'client_type', $subscriber_details )) {
				$subscriber_details ["client_type"] = '';
			}
        } elseif (!UtilityMethods::is_omniclient_service_bundle($subscriber_details ["service_set_value"])) {
            $subscriber_details ["client_type_id"] = '';
            $subscriber_details ["client_type"] = '';
        }

        if (array_key_exists('call_me_auth_token_id', $old_subscriber_details)) {
            $old_subscriber_details['call_me_auth_token_name'] = null;
            $callMeAuthToken = CallMeAuthTokenDao::readByID(
                $connection,
                $old_subscriber_details['call_me_auth_token_id']
            );
            if (UtilityMethods::isNotEqual($callMeAuthToken, false)) {
                $old_subscriber_details['call_me_auth_token_name'] = $callMeAuthToken->getName();
            }
        }

		// Copy Missing values from subscriber details in DB
		$subscriber_details = array_merge ( $old_subscriber_details, $subscriber_details );
        if (!isset($param_array['settings']['destination']) && !empty($old_subscriber_details['destination'])) {
            $subscriber_details['destination'] = '';
        }
		$this->_unset_fields_based_on_service_set ( $subscriber_details );
		$this->_set_subscriber_type ( $subscriber_details );

		$errror = SubscriberValidator::validate_subscriber_details(
            $connection,
            $param_array,
            CommonConstant::ACTION_TYPE_EDIT,
            $subscriber_details,
            $old_subscriber_details,
            $individual,
            $this->fromMigration
        );

		if (UtilityMethods::check_validation_error_exist ( $errror )) {
			return $errror;
		}

		// throw resource not exist and user not active error
		if (isset ( $old_subscriber_details ["ERROR_CODE"] )) { // Invalid Subscriber User Id
			return $old_subscriber_details;
		}

		if (UtilityMethods::isNotEqual ( $old_subscriber_details ["status"], ProvisioningConstant::SUBSCRIBER_STATUS_ACTIVE )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Status is Not Active for user Id..." . $old_subscriber_details ["user_id"] );
			}
			return SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_IS_NOT_ACTIVE, null );
		}

		// ACL-15222 Etisalat Specific Fix
		$e_product_name = SubscriberConstant::CALL_PERMISSION_RESTRICTED_PRODUCT;
		$e_call_permisson = SubscriberConstant::CALL_PERMISSION_RESTRICTED_VALUE;
		if (in_array($e_product_name, $subscriber_details['products_details'])) {
			if (in_array($e_product_name, $old_subscriber_details['products_details'])) {
				if ((isset($subscriber_details['call_permission']) && $subscriber_details['call_permission'] != $e_call_permisson) ||
					(isset($subscriber_details['call_forward_permission']) && $subscriber_details['call_forward_permission'] != $e_call_permisson)) {
					$subscriber_details['call_permission'] = $e_call_permisson;
					$subscriber_details['call_forward_permission'] = $e_call_permisson;
				}
			}
		}

		$subscriber_details ["domain"] = $group_details->top_level_domain;
		$subscriber_details ["group_id"] = $group_details->group_id;
		$subscriber_details ["user_id"] = UtilityMethods::get_subscriber_id ( $update_user_id ) . "@" . $group_details->top_level_domain;
		$subscriber_details ["subscriber_id"] = $old_subscriber_details ["subscriber_id"];
		// check first name and last name of mida user duplicate
		if(UtilityMethods::is_mida_bundle ( $subscriber_details ["service_set_value"] )){
			if(!MidaUserDao::is_mida_valid_name_for_update($connection, $subscriber_details['first_name'], $subscriber_details['last_name'],  $subscriber_details ["group_id"], UtilityMethods::is_mida_bundle ( $old_subscriber_details ["service_set_value"] ), $old_subscriber_details['first_name'], $old_subscriber_details['last_name'])){
				$response_array ["ERROR_CODE"] = ApiResponseConstant::MIDA_NAME_UPDATE_NOT_VALID;
				return $response_array;
			}
		}
		// Check the compatibility of mida production
		if(UtilityMethods::is_mida_bundle ( $subscriber_details ["service_set_value"] )){
			$valid_products_mida = UtilityMethods::valid_products_mida ( $subscriber_details ["service_set_value"] );
			if(!$valid_products_mida){
				return $this->_build_error_message ( ApiResponseConstant::INCOMPATABLE_PRODUCTS, "" );
			}
		}

        //check if user remove a number and get missing_did_number as array
        $missing_did_number = array();
        if (!empty($old_subscriber_details['voip_numbers'])) {
            foreach ($old_subscriber_details['voip_numbers'] as $key => $value) {
                if (!in_array($value, $subscriber_details['voip_numbers'])) {
                    array_push($missing_did_number, $value);
                }
            }
            // if "voip_numbers" deleted...
            if (UtilityMethods::isEqual(count($subscriber_details['voip_numbers']), 0)) {
                $subscriber_details["voicemail_service"] = ProvisioningConstant::VOICEMAIL_SERVER_NONE;
            }
        }

        //check is there any VoIP Number diff for KLS-017 subs
        if (UtilityMethods::isLiveSupportInboundVoiceServiceBundle($subscriber_details['service_set_value'])
            && UtilityMethods::isNotEqual(
                $subscriber_details['voip_numbers'][0], $old_subscriber_details['voip_numbers'][0])
        ) {
            return SubscriberValidator::build_error_message(
                ApiResponseConstant::SUBSCRIBER_UNABLE_TO_UPDATE_VOIP_NUMBER, ''
            );
        }

		//get all device button by subscriber
		$set_as_target_subscriber_for_device_keys = DeviceButtonsDao::get_device_button_details_by_target_subscriber($connection, array($subscriber_details['user_id']), null);
		if(isset($subscriber_details['voip_numbers']) && !empty($missing_did_number)){
			//old function
		    // $remove_device_buttons_by_target_numbers = $this->remove_device_buttons_by_target_numbers($connection, $subscriber_details['user_id'], $subscriber_details ["group_id"], array_diff($subscriber_details['target_numbers'], $subscriber_details['voip_numbers']));

		    //This code below to get user id of did number
		    if (isset ( $set_as_target_subscriber_for_device_keys )) {
                //get device button has feature BLF, BLF speed dial, Call Park Directed
	            $device_parameters_for_target_sub = array ();
	            foreach ( $set_as_target_subscriber_for_device_keys as $keys ) {
	                if ($keys ['feature'] == DeviceParameterConstant::BLF || $keys ['feature'] == DeviceParameterConstant::BLF_SPEED_DIAL || $keys ['feature'] == DeviceParameterConstant::CALL_PARK) {
	                    array_push ( $device_parameters_for_target_sub, $keys );
	                }
	            }
	            if (isset ( $device_parameters_for_target_sub )) {
	                $device_param_id = array();
	                //From device param id to get user id of device key choosing this subscriber
	                foreach($device_parameters_for_target_sub as $key => $value){
	                    array_push($device_param_id, $value['device_param_id']);
	                }
	                $parameter_array = array();
	                if(!empty($device_param_id)){
                        $parameter_array = DeviceParameterDao::get_device_parameter_by_param_id($connection, $device_param_id, "device_parameter_group_id");
		                $device_parameter_array = array();
		                $device_parameter_group_id = array();
		                if(!empty($parameter_array)){
		                    foreach($parameter_array as $key => $value){
		                        $device_parameter_array[] = $value['device_parameter_group_id'];
		                    }
		                    $device_parameter_group_id = DeviceParameterDao::get_device_parameter_by_parameter_group_id($connection, $device_parameter_array);
		                    $val_parameter = array();
			                if(!empty($device_parameter_group_id)){
			                    foreach($device_parameter_group_id as $key => $value){
			                        if($value['parameter'] == 'reg.1.address'){
			                           $val_parameter[] = $value['value'];
			                        }
			                    }
			                }
			                if(!empty($val_parameter)){
		                        //Remove address book Entries to avoid error unique label (for Call Park Directed)
		                        foreach($val_parameter as $key => $value){
									$subscriber_details_pa = array("prov_system_id"=>$subscriber_details['prov_system_id'], "user_id"=>$value, "group_id"=> $subscriber_details['group_id']);
									$pa = new models\external\prov\pa\Pa ();
									$addressbook_response = $pa->getAddressBook($connection,$subscriber_details_pa);
									if(isset($addressbook_response) && is_array($addressbook_response)){
										foreach($addressbook_response as $addressbook){
											$parameter_array_pa ["v"] = array($addressbook['name']);
											$response = $pa->removeAddressBookEntries($connection,$subscriber_details_pa,$parameter_array_pa);
										}
									}
		                        }
			                }
		                }
	                }
				}

				//Remove current key and set it as Clear Line Key
				$device_button_facade = new DeviceButtonFacade();
                $device_button_facade->remove_blf_lines_set($connection, $device_parameters_for_target_sub, $group_details->group_id);
			}
		}

        // Check VoIP number is valid
        $VoIPNumbers = $subscriber_details['voip_numbers'];
        $serviceSetValues = $subscriber_details["service_set_value"];

        if (
            (!UtilityMethods::is_kbs_api_consumer_service_bundle($serviceSetValues) && !UtilityMethods::isKbsApiCallMeServiceBundle($serviceSetValues))
            && (UtilityMethods::is_api_consumer_service_bundle($serviceSetValues) || UtilityMethods::isKbsApiCallMePSTNServiceBundle($serviceSetValues) || UtilityMethods::is_api_callme_service_bundle($serviceSetValues))
        ) {
            if (count($VoIPNumbers) > 1) {
                $this->_error("Only 1 VoIP number is allowed to be assigned to subscriber.");
                return SubscriberValidator::build_error_message(ApiResponseConstant::SUBSCRIBER_UNABLE_TO_SAVE_ONLY_ONE_VOIP_NUMBER, "voip_numbers");
            }
            if (UtilityMethods::isEmpty($VoIPNumbers)) {
                $this->_error("VoIP numbers cannot be empty.");
                return SubscriberValidator::build_error_message(ApiResponseConstant::VOIP_EMPTY, "voip_numbers");
            }
        }

        if (UtilityMethods::isNotEmpty($VoIPNumbers)) {
            foreach ($VoIPNumbers as $VoIP) {
                if (UtilityMethods::isNull($VoIP)) {

                    // Check the KBS_APICONSUMER service set is available
                    if (!UtilityMethods::is_kbs_api_consumer_service_bundle($subscriber_details['service_set_value'])
                        || (UtilityMethods::is_kbs_api_consumer_service_bundle($subscriber_details['service_set_value'])
                            && UtilityMethods::is_VoIP_number_not_empty($VoIP))) {

                        if ($this->_isErrorEnabled()) {
                            $this->_error('VoIP Number provided by user is empty...Please enter VoIP numbers.');
                        }

                        $response_array ['ERROR_CODE'] = ApiResponseConstant::VOIP_EMPTY;
                        $response_array ['ERROR_MESSAGE'] = $VoIP;
                        return $response_array;
                    }
                } elseif (
                    !preg_match('/^[0-9]+$/', $VoIP)
                    || strlen($VoIP) > SubscriberConstant::VoIP_NUMBER_MAX_LENGTH
                    || strlen($VoIP) < SubscriberConstant::VoIP_NUMBER_MIN_LENGTH
                ) {

                    if ($this->_isErrorEnabled()) {
                        $this->_error('VoIP Number provided by user is invalid... VoIP is must be number.');
                    }

                    $response_array ['ERROR_CODE'] = ApiResponseConstant::INVALID_VOIP_FORMAT;
                    $response_array ['ERROR_MESSAGE'] = $VoIP;
                    return $response_array;
                }
            }
        }


        // check voip alias in use sdc
        if (isset($subscriber_details["voip_alias"])) {
            $sub_alias = explode(" ", $subscriber_details["voip_alias"]);
            foreach ($sub_alias as $alias) {
                $sdc = ShortDialCodeDao::get_sdc_by_dial_code($connection, $alias, $subscriber_details["group_id"]);
                $sdc_by_number = ShortDialCodeDao::get_sdc_by_number($connection, $alias, $subscriber_details["group_id"]);
                if ($sdc || $sdc_by_number) {
                    $this->_error("User Alias provided by user are invalid...User Alias is the same value with short dial codes " . $alias);
                    $response_array["ERROR_CODE"] = ApiResponseConstant::INVALID_ALIAS_OF_SUBSCRIBER_IS_IN_USE_BY_SHORT_DIAL_CODE;
                    $response_array["ERROR_MESSAGE"] = $alias;
                    return $response_array;
                }
            }
            $userID = UtilityMethods::get_subscriber_id($update_user_id);
            // Check voip alias and voip numbers are same or not
            foreach ($VoIPNumbers as $VoIP) {
                if (UtilityMethods::isEqual($VoIP, $subscriber_details['voip_alias'])) {
                    $response_array["ERROR_CODE"] = ApiResponseConstant::ALIAS_AND_USER_ID_MUST_BE_UNIQUE;
                    $response_array["ERROR_MESSAGE"] = "";
                    return $response_array;
                }
                //check voip numbers and user id are same or not
                if (UtilityMethods::isEqual($VoIP, $userID)) {
                    return $this->_build_error_message(ApiResponseConstant::USER_ID_CAN_NOT_BE_SAME_WITH_VOIP_NUMBER, $VoIP);
                }
            }
        }

        //update device buttons and KEMs
        if (isset($old_subscriber_details['devices_with_buttons_set'])) {
            if (isset($subscriber_details['devices']) && is_array($subscriber_details['devices'])) {
                $devices_to_change = $subscriber_details['devices'];
                foreach ($devices_to_change as $key => $value) {
                    $devices_to_change[$key] = str_replace(":", "", $value);
                }
            }
            $difference = array_diff($old_subscriber_details['devices_with_buttons_set'], $devices_to_change);
            //Delete any key expansion modules of removed devices with no device buttons set
            $removed_devices_with_no_device_buttons_set = array_diff($old_subscriber_details['devices'], $devices_to_change);
            if ($this->isItOperation() && isset($difference) && count($difference) > 0) {
                return [
                    "ERROR_CODE" => ApiResponseConstant::IT_OPERATIONS_PERMISSION_RULE,
                    "ERROR_MESSAGE" => $this->_other_error_message[OtherConstant::DO_NOT_PERMISSSION_TO_MODIFY_SUBSCRIBER_DEVICES]
                ];
            }
            $removed_devices_array = array_unique(array_merge($difference, $removed_devices_with_no_device_buttons_set));
			if (!empty($removed_devices_array)) {
				foreach ($removed_devices_array as $mac){
					$is_generic_device = GenericDeviceDao::get_generic_details_by_mac($connection,$mac);
					if($is_generic_device!=false || (is_array($is_generic_device) && !empty($is_generic_device))){
						continue;
					}
					$device_buttons_facade = new DeviceButtonFacade ();
					$delete_buttons = $device_buttons_facade->clear_all_buttons($group_details->group_id, $mac);
					if(is_array($delete_buttons) && array_key_exists('ERROR_CODE', $delete_buttons)){
						return $delete_buttons;
					}
					$delete_buttons = $device_buttons_facade->remove_kem($mac, "0", true);
					//Clear Group Params
					$device_parameter_group_device_details = DeviceParameterDao::get_device_parameter_group_device_details($connection, $group_details->group_id, $mac);
					foreach ($device_parameter_group_device_details as $key => $value) {
						DeviceParameterDao::delete_device_from_device_parameter_group($connection, $value["terminal_id"]);
					}
				}
			}
        }

        //if devices unassigned from subscriber are assigned to paging groups we want to remove them from paging group
        if(isset($old_subscriber_details['mac_with_paging'])){
            if(isset($subscriber_details['devices']) && is_array($subscriber_details['devices'])){
				$devices_to_change=$subscriber_details['devices'];
				foreach($devices_to_change as $key=>$value){
					$devices_to_change[$key]=str_replace(":","",$value);
				}
			}
			$difference = array();
			$removed_devices_with_no_paging_set = array();
			$removed_devices_array = array();
			$difference = array_diff($old_subscriber_details['devices_with_buttons_set'], $devices_to_change);
            $removed_devices_with_no_paging_set = array_diff($old_subscriber_details['devices'], $devices_to_change);
            $removed_devices_paging_set_array = array_unique(array_merge($difference, $removed_devices_with_no_paging_set));
            if(isset($removed_devices_paging_set_array)){
                $paging_group_facade = new PagingGroupFacade();
                $remove_device_paging_group = $paging_group_facade->remove_device_from_paging_group($connection, $removed_devices_paging_set_array, $group_details->group_id);
            }
        }
		$user_id = $subscriber_details ["user_id"];

		// set eup phone button configuration enabling

		$return_error = false;
		if (isset($subscriber_details ["allow_eup_config"]) && UtilityMethods::isNotEmpty($subscriber_details ["allow_eup_config"])){
            if (
                UtilityMethods::isNotEqual($subscriber_details['allow_eup_config'], CommonConstant::ENABLE)
                && UtilityMethods::isNotEqual($subscriber_details['allow_eup_config'], CommonConstant::DISABLE)
            ) {
                $subscriber_details['allow_eup_config'] = UtilityMethods::isEqual($subscriber_details['allow_eup_config'], 1) ? CommonConstant::ENABLE : CommonConstant::DISABLE;
            }

			$validate_enabling_allow_sub = DeviceButtonValidator::validate_enabling_allow_sub ($subscriber_details, CommonConstant::ACTION_TYPE_EDIT);

		    if(array_key_exists("validation_errors", $validate_enabling_allow_sub)) {
		        $response_array ["ERROR_CODE"] = ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS;
		        $response_array ["ERROR_MESSAGE"] = key($validate_enabling_allow_sub['validation_errors']);
		        return $response_array;
		    }
		    $phonebutton_config_is_enabled = $this->is_phonebutton_config_enabled($subscriber_details ["group_id"], $subscriber_details ["user_id"]);
		    if(array_key_exists("ERROR_CODE", $phonebutton_config_is_enabled)) {
		        return $phonebutton_config_is_enabled;
		    }
		    $subscriber_details ["allow_eup_config"] = ($subscriber_details ["allow_eup_config"] == 'enabled') ? '1':'0';
		    if($phonebutton_config_is_enabled['is_phonebutton_enabled'] != '1') {
		        $subscriber_details['allow_eup_config'] = '0';
		    }
		    $eup_portal_phone_enable = SubscriberDao::set_eup_portal_phone_enabling($connection, $subscriber_details ["user_id"], $subscriber_details ["allow_eup_config"]);
		    if (!$eup_portal_phone_enable){
		        $return_error = true;
		    }
		}
		if ($return_error){
		    if ($this->_isErrorEnabled ()) {
		        $this->_error ( "EUP portal phone button configuration enabling has failed " . $user_id );
		    }
		    $response_array ["ERROR_CODE"] = ApiResponseConstant::SET_EUP_PORTAL_PHONEBUTTON_ENABLING_FAILED;
		    $response_array ["ERROR_MESSAGE"] = $user_id;
		    return $response_array;
		}

		//Only delete subscriber test if change from omni client to non omni client
		if (!UtilityMethods::is_omniclient_service_bundle($subscriber_details["service_set_value"])&&UtilityMethods::is_omniclient_service_bundle($old_subscriber_details["service_set_value"])){
			/* Delete if this subscriber is test client */
			$test_subscriber = ClientBrandingDao::get_test_subscriber($connection, $user_id, $subscriber_details ["group_id"]);
			if($test_subscriber)
				ClientBrandingDao::delete_all_subscriber_test($connection, $user_id, $subscriber_details ["group_id"]);
		}

		if (is_array ( $response_array ) && array_key_exists ( "ERROR_CODE", $response_array )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( "Products provided by user are invalid...(" . $response_array ["ERROR_CODE"] . ") - " . $user_id );
			}
			return $response_array;
		}
		if ($product_details === false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Products provided by user are invalid..." . $user_id );
			}
			return SubscriberValidator::build_error_message ( ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS, "products_details" );
		}
		unset ( $subscriber_details ["products_details"] );

		if ($this->_is_field_not_empty ( $subscriber_details, "site_identifier" )) {
			$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $subscriber_details ["site_identifier"] );
			if ($site_service_information === false) {
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Site Identifier provided by user is invalid..." . $user_id );
				}
				return SubscriberValidator::build_error_message ( ApiResponseConstant::SITE_IDENTIFIER_NOT_EXIST, null );
			}

            $megaSubscriberDetails = SubscriberDao::get_subscriber_details_by_userid($connection, $subscriber_details['user_id'],
                $group_details->group_id, 'is_default_subdomain_subscriber');
            if ($megaSubscriberDetails['is_default_subdomain_subscriber']) {
                $subscriber_details['is_default_subdomain_subscriber'] = true;
                $site_service_information['megaDomainPath'] = CommonConstant::DEFAULT_MODE_SITE_NAME . "."
                    . CommonConstant::DEFAULT_MODE_SMB_NAME . "." . $group_details->top_level_domain;
                $subscriber_details['sitePublicNumber'] = $site_service_information['public_number'];
            }

			$subscriber_details ["site_id"] = $site_service_information ["site_id"];
            $subscriber_details ["site_alias_prefix"] = $site_service_information ["alias_prefix"];
			$subscriber_details ["site_type"] = $site_service_information["type"];
			$subscriber_details ["site_vm_switch"] = $site_service_information["vm_switch"];
			$old_site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $old_subscriber_details ["site_identifier"] );
			$old_subscriber_details ["site_type"] = $old_site_service_information["type"];
			$old_subscriber_details ["site_vm_switch"] = $old_site_service_information["vm_switch"];
			if (UtilityMethods::isEqual ( $old_subscriber_details ["default_status"], ProvisioningConstant::DEFAULT_STATUS_INACTIVE )) {
				$subscriber_details ["default_status"] = $site_service_information ["default_status"];
			}
		}  // end of if($this->_is_field_not_empty($subscriber_details, "site_identifier"))
		else {
			$subscriber_details ["site_id"] = $old_subscriber_details ["site_id"];
			$subscriber_details ["site_identifier"] = $old_subscriber_details ["site_identifier"];
            $subscriber_details ["site_alias_prefix"] = $old_subscriber_details ["site_alias_prefix"];
			$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $old_subscriber_details ["site_identifier"] );
			$subscriber_details ["site_type"] = $site_service_information["type"];
			$subscriber_details ["site_vm_switch"] = $site_service_information["vm_switch"];
		} // end of else-if($this->_is_field_not_empty($subscriber_details, "site_identifier"))

        //check sum user alias and site alias
        if (UtilityMethods::isNotEmpty($subscriber_details['voip_alias'])) {
            $subAlias = explode(' ', $subscriber_details['voip_alias']);
            foreach ($subAlias as $alias) {
                if ((strlen($alias) + strlen($subscriber_details['site_alias_prefix'])) > SiteConstant::USER_ALIAS_AND_SITE_ALIAS_LIMIT) {
                    if ($this->_isErrorEnabled()) {
                        $this->_error('The sum of user alias and site alias can not be longer than 13 characters' . $subscriber_details['site_alias_prefix'] . ' ' . $alias);
                    }
                    return [
                        'ERROR_CODE' => ApiResponseConstant::SITE_AND_USER_ALIAS_LONGER_THAN_13_CHARACTERS,
                        'ERROR_MESSAGE' => $subscriber_details['site_alias_prefix'] . ' ' . $alias
                    ];
                }
            }
        }

        $AADirectorySyncValidationResponse = AADirectorySyncFacade::factory($connection)->validateSubscriberDetails($subscriber_details, $old_subscriber_details);
        if (array_key_exists('ERROR_CODE', $AADirectorySyncValidationResponse)) {
            return $AADirectorySyncValidationResponse;
        }

		/**
		 * ACL-1792 Deny site change on subscriber to restricted permissions
		 * Remove the ability for restricted permissions, Operations or Clerk, to change a subscriber's site.
		 */
		if (UtilityMethods::isNotEqual ( $subscriber_details ["site_id"], $old_subscriber_details ["site_id"] )) {
			$site_change_allowed_roles = array (
					PermissionConstant::OPERATIONS_PERMISSION,
					PermissionConstant::CLERK_PERMISSION,
                    PermissionConstant::IT_OPERATIONS_PERMISSION,
			);

			if (count ( array_intersect ( $site_change_allowed_roles, CommonHelper::getPresentationValue ( "permissions" ) ) ) == 0) {
				return $this->_build_error_message ( ApiResponseConstant::RESTRICTED_PERMISSION_USER_CANNOT_CHANGE_SITE, "" );
			}
			$subscriber_details ["update_site_field"] = TRUE;
		}


		/**
		 * ACL-3850 Individual provisioning of subscribers in VM Overay site
		 * Prevent paassword change for subscriber in VM overlay site.
		 * Prevent change of site to a VM overlay site
		 */

		if (UtilityMethods::isEqual ( $subscriber_details ["site_type"], SiteConstant::SITE_TYPE_VMOVERLAY )){
			if (@$subscriber_details ["update_password_field"]){
				return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_PASSWORD_CHANGE_NOT_ALLOWED, "" );
			}
			if (@$subscriber_details ["update_site_field"]){
				return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_SITE_CHANGE_TO_VMOVERLAY_NOT_ALLOWED, "" );
			}
		} elseif (UtilityMethods::isEqual ( $old_subscriber_details ["site_type"], SiteConstant::SITE_TYPE_VMOVERLAY )){
				$individual = new models\external\prov\Individual();
				$input_param ['top_level_domain'] = $group_details->top_level_domain;
				$input_param ['prov_system_id'] = $subscriber_details ["prov_system_id"];
				$input_param ['user_id'] = $subscriber_details ["user_id"];
				$input_param ['services'] = "cfwdvariants";
				$individual->removeServicesFromUser($connection, $input_param);
				$input_param ['services'] = "advscr";
				$individual->addServicesForUser($connection, $input_param);
				$input_param ['services'] = "nuvia_default";
				$individual->setSystemProfileForUser_AdvScrSPU($connection, $input_param);
		}

		if (ProvUtility::isSubscriberConfigured ( $subscriber_details ["subscriber_type"] )) {
			if (ProvUtility::isSubscriberNodCaller ( $old_subscriber_details ["subscriber_type"] ) || ProvUtility::isSubscriberNodListener ( $old_subscriber_details ["subscriber_type"] )) {
				$subscriber_details ["subscriber_type"] = $old_subscriber_details ["subscriber_type"];
			}
		}

		if (ProvUtility::isSubscriberSipTrunk ( $subscriber_details ["subscriber_type"] )) {
			if (UtilityMethods::isNotEqual ( $site_service_information ["type"], SiteConstant::SITE_TYPE_PBX )) {
				return $this->_build_error_message ( ApiResponseConstant::SIP_PBX_SUBSCRIBER_SHOULD_HAVE_CONNECTED_PBX_TYPE_SITE, "" );
			}
			$site_sip_trunk_details = SiteDao::get_pbx_details ( $connection, $site_service_information ["site_id"], TRUE );
			if (UtilityMethods::isEmpty ( $site_sip_trunk_details )) {
				return $this->_build_error_message ( ApiResponseConstant::SIP_PBX_SUBSCRIBER_SHOULD_HAVE_CONNECTED_PBX_TYPE_SITE, "" );
			}
			$site_service_information = array_merge ( $site_service_information, $site_sip_trunk_details );
		} else {
			if (UtilityMethods::isEqual ( $site_service_information ["type"], SiteConstant::SITE_TYPE_PBX )) {
				return $this->_build_error_message ( ApiResponseConstant::SIP_PBX_SITE_CANNOT_ASSIGNED_TO_NORMAL_SUBSCRIBER, "" );
			}
		}

		$subscriber_type = $subscriber_details ["subscriber_type"];
		$service_set_value = $subscriber_details ["service_set_value"];

		$old_subscriber_type = $old_subscriber_details ["subscriber_type"];
		$old_service_set_value = $old_subscriber_details ["service_set_value"];

		$ipscape_new = UtilityMethods::is_ipscape_bundle ( $service_set_value );
		$ipscape_old = UtilityMethods::is_ipscape_bundle ( $old_service_set_value );

		$mida_new = UtilityMethods::is_mida_bundle ( $service_set_value );
		$mida_old = UtilityMethods::is_mida_bundle ( $old_service_set_value );

		if (($ipscape_new && ! $ipscape_old) || (! $ipscape_new && $ipscape_old)) {
			$ipscape_response = IpScapeValidator::pre_process_ipscape_details ( $connection, $group_details );

			if (is_array ( $ipscape_response )) {
				return $ipscape_response;
			}

			$ipscape_facade = new IpscapeFacade ();

			$new_agent_count = $ipscape_facade->get_agent_count_for_domain ( $group_details->group_id );

			if ($ipscape_new) { // new ss has ipscape, old one didn't. +1 sub
				$new_agent_count += 1;
			} else { // process of elimination, old ss has ipscape and new one doesn't. -1 sub
				$new_agent_count -= 1;
			}

			if ($new_agent_count < 0) {
				$new_agent_count = 0;
			}

			$ipscape_facade->update_max_agents_for_group ( $group_details->group_id, $new_agent_count );
		}

		if ($mida_new && ! $mida_old) {
			$mida_response = MidaValidator::pre_process_mida_details ( $connection, $group_details );
			if (is_array ( $mida_response )) {
				return $mida_response;
			}

			$new_prod_id_list = explode ( ',', $subscriber_details ["product_ids"] );

			$this->handle_new_mida_purchase($connection, $new_prod_id_list, $group_details, $subscriber_details);
		}

		if (UtilityMethods::is_kandy_msisdn_bundle ( $service_set_value ) && (UtilityMethods::isNotEqual ( $subscriber_details ["mobile_number"], $old_subscriber_details ["mobile_number"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["user_password"], $old_subscriber_details ["user_password"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["first_name"], $old_subscriber_details ["first_name"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["last_name"], $old_subscriber_details ["last_name"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["voice_mail_directory_number"], $old_subscriber_details ["voice_mail_directory_number"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["email"], $old_subscriber_details ["email"] ))) {
			$update = 1;
			if (UtilityMethods::isNotEqual ( $subscriber_details ["mobile_number"], $old_subscriber_details ["mobile_number"] ))
				$update = 0;
			$response = $this->check_kandy_msisdn_number ( $connection, $group_details, $subscriber_details, $update );
			if (array_key_exists ( "ERROR_CODE", $response ))
				return $response;
			$subscriber_details ["mobile_country_code"] = $response [ProvisioningConstant::A2_RESPONSE]->countryCode;
			$this->_debug ( "mobile_country_code => " . print_r ( $subscriber_details ["mobile_country_code"], true ) );
		}

        if (UtilityMethods::isNotEqual($subscriber_details['mobile_number'], $old_subscriber_details['mobile_number'])) {
            $pa = new Pa();
            $getCallActionRoutesResponse = $pa->getCallActionRoutes(
                $connection,
                $subscriber_details['prov_system_id'],
                $subscriber_details['user_id']
            );
            if (is_array($getCallActionRoutesResponse)) {
                foreach ($getCallActionRoutesResponse as $route) {
                    if (UtilityMethods::isEqual($route['active'], 1)) {
                        $routeParams['active'] = $route['active'];
                        if (isset($route['termAction']['dests'][0]['destinations'])) {
                            foreach ($route['termAction']['dests'][0]['destinations'] as $key => $value) {
                                if ($value == $old_subscriber_details['mobile_number']) {
                                    $route['termAction']['dests'][0]['destinations'][$key] = $subscriber_details['mobile_number'];
                                }
                            }
                        }
                        $routeParams['termAction'] = $route['termAction'];
                        $pa->modifyCallActionRoute(
                            $connection,
                            $subscriber_details['prov_system_id'],
                            $subscriber_details['user_id'],
                            $route['name'],
                            $routeParams
                        );
                    }
                }
            }
        }

		/*
		 * If input contains product details array and produt details different from old details then
		 * possible that subscriber type might change
		 * else
		 * update details for existing product type
		 * end if
		 */
		$response = array ();
		if (UtilityMethods::isEqual ( $subscriber_type, $old_subscriber_type )) {
			if (ProvUtility::isSubscriberNonProvision ( $subscriber_type )) {
				$response = $this->_update_non_provision_subscriber_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
			} else if (ProvUtility::isSubscriberConfigured ( $subscriber_type ) || ProvUtility::isSubscriberNodCaller ( $old_subscriber_details ["subscriber_type"] ) || ProvUtility::isSubscriberNodListener ( $old_subscriber_details ["subscriber_type"] )) {
				$response = $this->_update_configured_subscriber_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
			} else if (ProvUtility::isSubscriberStandalone ( $subscriber_type )) {
				$response = $this->_update_standalone_subscriber_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
			}
			if (ProvUtility::isSubscriberSipTrunk ( $subscriber_type )) {
				$response = $this->_update_sip_trunk_subscriber_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
			}
		}  // end of if(subscriber type = old subscriber type)
		else {
			if (ProvUtility::isSubscriberNonProvision ( $old_subscriber_type )) {
				if (ProvUtility::isSubscriberConfigured ( $subscriber_type )) {
					$response = $this->_convert_non_provision_to_configured_subscriber_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
				} else if (ProvUtility::isSubscriberStandalone ( $subscriber_type )) {
					$response = $this->_convert_non_provision_to_standlaone_subscriber_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
				} elseif (ProvUtility::isSubscriberSipTrunk ( $subscriber_type )) {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( "CANNOT CONVERTED TO SIP PBX SUBSCRIBER - " . $old_subscriber_details ["user_id"] );
					}
					$response = SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_SIP_PBX_CANNOT_BE_CHANGED, null );
				}
			} else if (ProvUtility::isSubscriberConfigured ( $old_subscriber_type )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( "CANNOT CONVERTED FROM CONFIGURED SUBSCRIBER - " . $old_subscriber_details ["user_id"] );
				}
				$response = SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_NON_STANDALONE_TYPE_CANNOT_BE_CHANGED, null );
			} else if (ProvUtility::isSubscriberStandalone ( $old_subscriber_type )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( "CANNOT CONVERTED STANDALONE SUBSCRIBER - " . $old_subscriber_details ["user_id"] );
				}
				$response = SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_STANDALONE_TYPE_CANNOT_BE_CHANGED, null );
			} else if (ProvUtility::isSubscriberSipTrunk ( $old_subscriber_type )) {
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( "CANNOT CONVERTED FROM SIP PBX SUBSCRIBER - " . $old_subscriber_details ["user_id"] );
				}
				$response = SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_SIP_PBX_CANNOT_BE_CHANGED, null );
			}
		} // end of if(subscriber type != old subscriber type)

		if (is_array ( $response ) && array_key_exists ( 'ERROR_CODE', $response )) {
			return $response;
		}

		//for subscriber report
		$resStatus = SubscriberDao::get_restricted_status($connection, $old_subscriber_details['user_id']);
		if ($resStatus) {
			$old_subscriber_details['service_access_status'] = strtoupper(ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_DISPLAY_CONTENT_RESTRICTED);
			$subscriber_details['service_access_status'] = strtoupper(ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_DISPLAY_CONTENT_RESTRICTED);

			//if updating service sets disabled denyallcalls for restricted user, Perform A2 Call to restrict user again
			$individualProv = new Individual();
			$inputParam = [];
            $inputParam['top_level_domain'] = $group_details->top_level_domain;
            $inputParam['prov_system_id'] = $old_subscriber_details['prov_system_id'];
            $inputParam['user_id'] = UtilityMethods::get_subscriber_id($user_id) . '@' . $group_details->top_level_domain;
			$inputParam['services'] = 'denyallcalls';
			$individualProv->addServicesForUser($connection, $inputParam);
			$inputParam['func'] = 'setSystemProfileForUser_denyallcalls';
			$individualProv->setSystemProfileForUser_denyallcalls($connection, $inputParam);
			$inputParam['func'] = 'setSystemProfileForUser_denyalloutgoingcalls';
			$individualProv->setSystemProfileForUser_denyalloutgoingcalls($connection, $inputParam);
		}

        // START - Report for Subscriber provisioning changes.
        $this->subscriber_historic_report(ReportConstants::EVENT_TYPE_UPDATE, $group_details, $subscriber_details, $old_subscriber_details);
        // END - Report for Subscriber provisioning changes.

		// ACL 1388 Account Turn up Cache
		if (ProvUtility::isDefaultStatusActive ( $subscriber_details ["default_status"] ) && UtilityMethods::isNotEqual ( $subscriber_details ["sku"], $old_subscriber_details ["sku"] )) {
			$sync_invoice_process = new SyncInvoiceProcessFacade ();
			$sync_invoice_process->invoke_sync_invoice_process ( $connection, SyncInvoiceConstant::SYNC_INVOICE_TASK_TYPE_SUBSCRIBER, $group_details->group_id );
		}

        AADirectorySyncFacade::factory($connection)->syncSubscriberDetails($subscriber_details, $old_subscriber_details);

        if (
            isset($subscriber_details['scheduled_call_restriction'])
            && CTBSDao::getCTBSProfileByGroup($connection, $group_details->group_id)
        ) {
            $groupId = CommonHelper::getContextValue('group_id');
            $authCodeForSubscriber = $subscriber_details['authorization_code'] ?? '';
            $isAuthCodeParamEnabled = $subscriber_details['scheduled_call_restriction'] != CommonConstant::DISABLE;
            $oldAuthCode = $old_subscriber_details['settings']['authorization_code'];
            $ctbsFacade = new CTBSFacade();

            $ctbsCallTypes = $this->_generateCTBSArrayForSubscriber($subscriber_details['scheduled_call_restriction']);
            if ($isAuthCodeParamEnabled) {
                $ctbsFacade->enableCTBSForSubscriber($subscriber_details['user_id'], $groupId, $ctbsCallTypes);
                if (empty($authCodeForSubscriber)) {
                    $ctbsFacade->removeSubscriberAuthCode($subscriber_details['user_id'], $oldAuthCode);
                    $this->_debug('Authorization code is removed from ' . $authCodeForSubscriber);
                } else {
                    $ctbsFacade->setSubscriberAuthCode($subscriber_details['user_id'], $authCodeForSubscriber, $oldAuthCode);
                    $this->_debug('Authorization code is assigned to ' . $authCodeForSubscriber);
                }
            } else {
                $ctbsFacade->disableCTBSForSubscriber($subscriber_details['user_id'], $groupId);
                $ctbsFacade->removeSubscriberAuthCode($subscriber_details['user_id'], $oldAuthCode);
                $this->_debug('CTBS is disabled for subscriber and authorization code is removed from ' . $subscriber_details['user_id']);
            }
        }
    }

    // end of method update_subscriber_details()

	/**
	 * ACL-1690:Added Subsriber_password_change method,
	 * It calls the change Password method in Pa to avoid the reset of password.
	 */
	public function subscriber_password_change($user_id, $group_details, $parameter) {
		$group_id = $group_details->group_id;
		try {
			$connection = DbConnector::getConnection ();
			$db_subscriber_details = SubscriberDao::get_subscribers_details ( $connection, $group_details->group_id, $user_id );
			if ($db_subscriber_details === false) {
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Invalid User Id provided..." . $user_id );
				}
				return self::_build_error_message ( ApiResponseConstant::RESOURCE_NOT_EXISTS, "" );
			} // end of if($db_subscriber_details === false)
			try {

				$encrypt_password = UtilityMethods::sip_data_in ( $parameter ['password'] );
				if (is_array ( $encrypt_password ) && array_key_exists ( 'error', $encrypt_password )) {
					return self::_build_error_message ( ApiResponseConstant::INVALID_VALUES_IN_PARAMETERS, "user_password" );
				}

                $passwordPolicyResponse = $this->checkSubscriberPasswordPolicy($parameter['password'], $group_details);
                if (is_array($passwordPolicyResponse)
                    && array_key_exists('ERROR_CODE', $passwordPolicyResponse)) {
                    return $passwordPolicyResponse;
                }

				$connection->beginTransaction ();
				SubscriberDao::update_subscriber_password ( $connection, $user_id, $encrypt_password, $group_id );
				$paProv = new models\external\prov\pa\Pa ();
				$response = $paProv->changePassword ( $connection, $db_subscriber_details, $parameter );
				preg_match ( "/" . ProvisioningConstant::PROVISIONING_EXCEPTION . "/i", $response, $matches );
				if (count ( $matches ) > 0) {
					DbConnector::rollbackTransaction ( $connection );
					preg_match ( "/" . ProvisioningConstant::PROVISIONING_CHANGE_PASSWORD_MSG . "/i", $response, $matches );
					if (count ( $matches ) > 0) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( "PASSWORD NOT ACCEPTED" );
						}
					} // end of if(count($matches)>0)
					return self::_build_error_message ( ApiResponseConstant::SUBSCRIBER_USER_PASSWORD_UPDATE_FAILED, "" );
				}
				DbConnector::commitTransaction ( $connection );
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Update subscriber_password_change Failed!", $e );
				}
				throw $e;
			}
		} catch ( Exception $e ) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Update subscriber_password_change Failed!", $e );
			}
			throw $e;
		}
	}

	// end of method subscriber_password_change()
	public function activate_subscriber($user_id, $group_details, $connection = NULL) {
		try {
			$sync_invoice = false;

			if (UtilityMethods::isEmpty ( $connection )) {
				$connection = DbConnector::getConnection ();
				$sync_invoice = true;
			}
			$group_id = CommonHelper::getContextValue ( 'group_id' );
			$subscriber_details = $this->_get_subscriber_details ( $connection, $user_id, $group_details, true );
            unset($old_subscriber_details['public_charge_id']);
			if (isset ( $subscriber_details ["ERROR_CODE"] )) { // Invalid Subscriber User Id
				return $subscriber_details;
			}
			if ($subscriber_details ['default_status'] == ProvisioningConstant::DEFAULT_STATUS_ACTIVE) {
				return SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_DEFAULT_STATUS_ALREADY_ACTIVATED, null );
			}

			$call_executed_list = array ();
			try {
				$connection->beginTransaction ();

				$group_domain = $group_details->top_level_domain;
				if (UtilityMethods::isSMB ( $group_details->group_type )) {
					$group_domain = $group_details->smb_prefix . "." . $group_details->top_level_domain;
				}

				SubscriberDao::update_default_status ( $connection, $subscriber_details ["subscriber_id"], $group_id );

				SubscriberDao::insert_subscriber_invoice_details ( $connection, $subscriber_details, ReportConstant::SUBSCRIBER_INVOICE_ADDED_STATUS, $group_domain, ProvUtility::getPstnDidGroupId ( $group_details ) );

				if (ProvUtility::isSubscriberConfigured ( $subscriber_details ["subscriber_type"] ) || (ProvUtility::isSubscriberSipTrunk ( $subscriber_details ["subscriber_type"] ) && (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $subscriber_details ["menu"] ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $subscriber_details ["menu"] )))) {
					$subscriber_details ["default_status"] = ProvisioningConstant::DEFAULT_STATUS_ACTIVE;
					$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $subscriber_details ["site_identifier"] );
					$individualProv = new models\external\prov\Individual ();
                    if ($this->_is_field_not_empty($subscriber_details, "voip_numbers")) {
                        // START - Drop dids from vacant for assigning to the subscriber
                        $pstn_array = $subscriber_details['voip_numbers'];
                        $pstn_did_vacant_userid_array = [];
                        if (UtilityMethods::isNotEqual(count($pstn_array), 0)) {
                            $pstn_did_vacant_userid_array = PstndidDao::get_unique_vacant_user_id_for_pstndid_numbers(
                                $connection,
                                $pstn_array
                            );
                        }
                        if (UtilityMethods::isNotEqual(count($pstn_did_vacant_userid_array), 0)) {
                            if (VACANT_NUMBER_NEW_A2_SERVICE) {
                                $this->removeDIDFromVacantList(
                                    $connection,
                                    ProvUtility::getPstnDidDomain($connection, $group_details),
                                    ProvUtility::getPstnDidGroupId($group_details),
                                    $subscriber_details['voip_numbers']
                                );
                            } else {
                                $this->updateVacentPstndidNumbers(
                                    $connection,
                                    ProvUtility::getPstnDidDomain($connection, $group_details),
                                    ProvUtility::getPstnDidGroupId($group_details),
                                    $pstn_did_vacant_userid_array
                                );
                            }
                        }
                        // END

                        if (
                            $group_details->is_default_subdomains_enabled
                            && $site_service_information['is_default_subdomains_enabled']
                        ) {
                            $subscriber_details['sitePublicNumber'] = $site_service_information['public_number'];
                            $subscriber_details['is_default_subdomain_subscriber'] = SubscriberDao::get_subscriber_details_by_id(
                                $connection,
                                $subscriber_details['subscriber_id'],
                                $subscriber_details['group_id'],
                                'is_default_subdomain_subscriber'
                            )['is_default_subdomain_subscriber'];
                        }

                        $this->_saveVoipDetails($connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information);
                    }
						$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );

						if ($group_details->number_display_option != 1) {
							$this->_setDNandNQforUser1 ( $connection, $group_details, $subscriber_details, $site_service_information, $individualProv, $call_executed_list );
						}
				}

                AADirectorySyncFacade::factory($connection)->syncForSingleAction(
                    AADirectorySyncConstant::ACTION_SOURCE_SUBSCRIBER_ACTIVATION,
                    $subscriber_details
                );

				DbConnector::commitTransaction ( $connection );

                // Add Historical Report when Subscriber is Activated
                $this->subscriber_historic_report(ReportConstants::EVENT_TYPE_ACTIVATION, $group_details, $subscriber_details);

				// ACL 1388 Account Turn up Cache
				if ($sync_invoice) {
					$sync_invoice_process = new SyncInvoiceProcessFacade ();
					$sync_invoice_process->invoke_sync_invoice_process ( $connection, SyncInvoiceConstant::SYNC_INVOICE_TASK_TYPE_SUBSCRIBER, $group_id );
				}
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if (count ( $call_executed_list ) > 0) {
					$this->_saveVoipDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information );
					$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}
				if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
					return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
				}
				// catching Error
				if ($this->_isErrorEnabled ()) {
					$inputs = array (
							"GROUP_ID" => $group_id
					);
					$this->_error ( $this->_getVarDump ( $inputs ) . "activate_subscriber failed!", $e );
				}
				throw $e;
			}
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "activate_subscriber failed!", $e );
			}
			throw $e;
		}
	}

    /** Method to change restriction status
     *
     * @param string $update_user_id
     * @param object $group_details
     * @param array $paramArray
     * @return array|void
     */
    public function restrict_user($update_user_id, $group_details, $paramArray = [])
    {
        $this->_debug('# Subscriberfacade -> restrict_user');
        $this->_debug('# Subscriberfacade -> restrict_user -> update_user_id is ' . $update_user_id);
        $this->_debug('# Subscriberfacade -> restrict_user -> group_details is ' . var_export($group_details, true));
        $this->_debug('# Subscriberfacade -> restrict_user -> paramArray is ' . print_r($paramArray, true));

        $response_array = [];
        $connection = DbConnector::getConnection();

        //prechecks
        $subscriber_details = SubscriberDao::get_subscriber_details_by_user_id($connection, $update_user_id, $group_details->group_id, 'subscriber_type');
        if (UtilityMethods::isEmpty($subscriber_details)) {
            if ($this->_isErrorEnabled()) {
                $this->_error('# Subscriberfacade -> restrict_user -> Invalid User Id provided...' . $update_user_id);
            }
            $response_array['ERROR_CODE'] = ApiResponseConstant::RESOURCE_NOT_EXISTS;
            return $response_array;
        }
        if (!ProvUtility::isSubscriberConfiguredOrSipTrunk($subscriber_details['subscriber_type'])) {
            if ($this->_isDebugEnabled()) {
                $this->_debug('# Subscriberfacade -> restrict_user -> Service access status can be update only for configured/sip trunk subscribers. No operation performed for user ' . $update_user_id);
            }
            return;
        }
        $old_subscriber_details = $this->_get_subscriber_details($connection, $update_user_id, $group_details, true);
        if (is_array($old_subscriber_details) && array_key_exists('ERROR_CODE', $old_subscriber_details)) {
            $this->_error('# Subscriberfacade -> restrict_user -> Cannot getting old subscriber details for ' . $update_user_id);
            return $old_subscriber_details;
        }

        if (UtilityMethods::is_sip_pbx_basic_menu_bundle($old_subscriber_details['menu'])) {
            if ($this->_isDebugEnabled()) {
                $this->_debug('# Subscriberfacade -> restrict_user -> Service access status cannot be updated for sip pbx basic subscribers. No operation performed for user ' . $update_user_id);
            }
            return;
        }

        if (UtilityMethods::isNotEqual($old_subscriber_details['status'], ProvisioningConstant::SUBSCRIBER_STATUS_ACTIVE)) {
            if ($this->_isErrorEnabled()) {
                $this->_error('# Subscriberfacade -> restrict_user -> Subscriber Status is Not Active for user Id...' . $old_subscriber_details['user_id']);
            }
            return SubscriberValidator::build_error_message(ApiResponseConstant::SUBSCRIBER_IS_NOT_ACTIVE, null);
        }
        //precheck ends

        try {
            if (ProvUtility::isSubscriberConfiguredOrSipTrunk($old_subscriber_details['subscriber_type'])) {
                $connection->beginTransaction();

                //get restricted status of the subscriber
                $res_status = SubscriberDao::get_restricted_status($connection, $update_user_id);
                $this->_error('# Subscriberfacade -> restrict_user -> Subscriber restricted status is ' . $res_status['restricted']);

                $input_param = [];
                $input_param['top_level_domain'] = $group_details->top_level_domain;
                $input_param['prov_system_id'] = $old_subscriber_details['prov_system_id'];
                $input_param['user_id'] = UtilityMethods::get_subscriber_id($update_user_id) . '@' . $group_details->top_level_domain;
                $input_param['services'] = 'denyallcalls';

                // Perform A2 Call
                $individualProv = new Individual();

                if ($res_status) {
                    //if its restricted, remove restriction
                    $set_restricted_value = 0;
                    SubscriberDao::set_restricted_status($connection, $set_restricted_value, $update_user_id);
					$input_param['func'] = 'removeSystemProfileForUser_denyalloutgoingcalls';
					$old_subscriber_details['service_access_status'] = strtoupper(ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_DISPLAY_CONTENT_RESTRICTED);
                    if (!empty($paramArray['service_status'])) {
                        $subscriber_details['service_access_status'] = strtoupper($paramArray['service_status']);
                    }
                } else {
                    //enable deny all calls service
                    $individualProv->addServicesForUser($connection, $input_param);

                    //set users system profile
                    $input_param['func'] = 'setSystemProfileForUser_denyallcalls';
                    $individualProv->setSystemProfileForUser_denyallcalls($connection, $input_param);

                    //restrict subscriber
                    $set_restricted_value = 1;
                    SubscriberDao::set_restricted_status($connection, $set_restricted_value, $update_user_id);
					$input_param['func'] = 'setSystemProfileForUser_denyalloutgoingcalls';
					$subscriber_details['service_access_status'] = strtoupper(ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_DISPLAY_CONTENT_RESTRICTED);
                }

                if($individualProv->setSystemProfileForUser_denyalloutgoingcalls($connection, $input_param)) {
                    $this->_error('# Subscriberfacade -> restrict_user -> Deny all out going calls is failed!!');
                }

				DbConnector::commitTransaction($connection);

				//fill subscriber details for historic report
				$subscriber_details['user_id'] = $input_param['user_id'];
				$subscriber_details['domain'] = $input_param['top_level_domain'];
				$subscriber_details['group_id'] = $group_details->group_id;
				$subscriber_details['subscriber_id'] = $old_subscriber_details['subscriber_id'];
				$subscriber_details['prov_system_id'] = $input_param['prov_system_id'];
				$subscriber_details['subscriber_type'] = $old_subscriber_details['subscriber_type'];

				// START - Report for Subscriber provisioning changes.
                $this->subscriber_historic_report(ReportConstants::EVENT_TYPE_UPDATE, $group_details, $subscriber_details, $old_subscriber_details);
                // END - Report for Subscriber provisioning changes.
                if($res_status) {
                    $this->_debug('# Subscriberfacade -> restrict_user is success | User status changed to Active from Restrict | user id is ' . UtilityMethods::get_subscriber_id($update_user_id) . '@' . $group_details->top_level_domain);
                } else {
                    $this->_debug('# Subscriberfacade -> restrict_user is success | User status changed to Restrict from Active | user id is ' . UtilityMethods::get_subscriber_id($update_user_id) . '@' . $group_details->top_level_domain);
                }
            }
        } catch (Exception $e) {
            DbConnector::rollbackTransaction($connection);
            if ($this->_isErrorEnabled()) {
                $this->_error('Restrict Subscriber Service Status Access Failed!', $e);
            }
            if (is_a($e, 'models\external\prov\exception\CallFailedException')) {
                return $this->_build_error_message($e->getCode(), $e->getMessage());
            }
            return $this->_build_error_message(ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED, '');
        }
    }

	 /** Method to get restrict status of the subscriber
     *
     * @param string $subscriber_id
     * @return array
     */
	public function get_restricted_status($subscriber_id) {
		try {
			$connection = DbConnector::getConnection();
			$response['restrict_status'] = SubscriberDao::get_restricted_status($connection, $subscriber_id);
			return $response;
		} catch (Exception $e) {
			if ($this->_isErrorEnabled()) {
				$this->_error('Getting Subscriber Restrict Status Failed!', $e);
			}
		}
	}

	/*
	 * when subscriber activates a trial, the following states change
	 * default status <-- TRIAL from INACTIVE
	 * trial activation <-- current date
	 * trial expiry <-- current date + 30 days
	 * trial expiry action <-- customer(group) trial expriy action
	 *
	 */
	public function activate_trial_subscriber($user_id, $group_details, $connection = NULL, $is_new_user = false) {
		try {

			$sync_invoice = false;

			if (UtilityMethods::isEmpty ( $connection )) {
				$connection = DbConnector::getConnection ();
				$sync_invoice = true;
			}

			$group_id = CommonHelper::getContextValue ( 'group_id' );

			$subscriber_details = $this->_get_subscriber_details ( $connection, $user_id, $group_details, true );
            unset($old_subscriber_details['public_charge_id']);

			$subscriber_expiry_action = $group_details->trial_expiry_action;

			if (isset ( $subscriber_details ["ERROR_CODE"] )) { // Invalid Subscriber User Id
				return $subscriber_details;
			}

			if ($subscriber_details ['default_status'] == ProvisioningConstant::DEFAULT_STATUS_TRIAL && ! $is_new_user) {
				return SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_DEFAULT_STATUS_ALREADY_TRIAL, null );
			}

			$trial_date = SubscriberDao::get_trial_activation_date ( $connection, $subscriber_details ["subscriber_id"] );
			if (! empty ( $trial_date ['trial_activation'] )) {

				return $subscriber_details;
			}

			// trial activation <-- current date
			// trial expiry <-- current date + 30 days
			$nowDate = date ( "Y-m-d H:i:s" );

			// SubscriberDao::activate_trial($connection, $nowDate, $subscriber_details["subscriber_id"], $group_id);
			$finishDate = date ( 'Y-m-d H:i:s', strtotime ( TRIAL_LENGTH ) );
			// $finishDate -> format('Y-m-d H:i:s');
			// $finishDate -> format('Y-m-d H:i:s');
			$subscriber_details ['trial_expiry'] = $finishDate;

			$call_executed_list = array ();
			try {
                if(!DbConnector::inTransaction($connection)){
                    $connection->beginTransaction();
                }

				$group_domain = $group_details->top_level_domain;

				if (UtilityMethods::isSMB ( $group_details->group_type )) {
					$group_domain = $group_details->smb_prefix . "." . $group_details->top_level_domain;
				}

				$trial_activation_details = array ();
				$trial_activation_details ["nowDate"] = $nowDate;
				$trial_activation_details ["finishDate"] = $finishDate;
				$trial_activation_details ["expiryAction"] = $subscriber_expiry_action;
				$trial_activation_details ["subscriberId"] = $subscriber_details ["subscriber_id"];
				$trial_activation_details ["groupId"] = $group_id;

				SubscriberDao::activate_trial ( $connection, $trial_activation_details );

				// SubscriberDao::update_default_status_trial($connection, $subscriber_details["subscriber_id"], $group_id);

				SubscriberDao::insert_subscriber_invoice_details ( $connection, $subscriber_details, ReportConstant::SUBSCRIBER_INVOICE_ADDED_STATUS, $group_domain, ProvUtility::getPstnDidGroupId ( $group_details ) );

				// ACL-25361 ...
				$old_subscriber_details = $subscriber_details;

				if (ProvUtility::isSubscriberConfigured ( $subscriber_details ["subscriber_type"] ) || (ProvUtility::isSubscriberSipTrunk ( $subscriber_details ["subscriber_type"] ) && (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $subscriber_details ["menu"] ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $subscriber_details ["menu"] )))) {
					$subscriber_details ["default_status"] = ProvisioningConstant::DEFAULT_STATUS_TRIAL;
					$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $subscriber_details ["site_identifier"] );
					$individualProv = new models\external\prov\Individual ();
					if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" )) {

                        if (
                            $group_details->is_default_subdomains_enabled
                            && $site_service_information['is_default_subdomains_enabled']
                        ) {
                            $subscriber_details['sitePublicNumber'] = $site_service_information['public_number'];
                            $subscriber_details['is_default_subdomain_subscriber'] = SubscriberDao::get_subscriber_details_by_id(
                                $connection,
                                $subscriber_details['subscriber_id'],
                                $subscriber_details['group_id'],
                                'is_default_subdomain_subscriber'
                            )['is_default_subdomain_subscriber'];
                        }

						$this->_saveVoipDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information );
						$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );

						if ($group_details->number_display_option != 1) {
							$this->_setDNandNQforUser1 ( $connection, $group_details, $subscriber_details, $site_service_information, $individualProv, $call_executed_list );
						}
					}
				}

				DbConnector::commitTransaction ( $connection );

				// ACL-25361 ... Report for if default_status is changing INACTIVE to TRIAL...
				if(UtilityMethods::isEqual($old_subscriber_details["default_status"], ProvisioningConstant::DEFAULT_STATUS_INACTIVE)){
					$old_subscriber_details["service_access_status"] = ProvisioningConstant::DEFAULT_STATUS_INACTIVE;
					$subscriber_details["service_access_status"] = ProvisioningConstant::DEFAULT_STATUS_TRIAL;
				}
				$this->subscriber_historic_report(ReportConstants::EVENT_TYPE_UPDATE, $group_details, $subscriber_details, $old_subscriber_details);

				// ACL 1388 Account Turn up Cache
				if ($sync_invoice) {
					$sync_invoice_process = new SyncInvoiceProcessFacade ();
					$sync_invoice_process->invoke_sync_invoice_process ( $connection, SyncInvoiceConstant::SYNC_INVOICE_TASK_TYPE_SUBSCRIBER, $group_id );
				}
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if (count ( $call_executed_list ) > 0) {
					$this->_saveVoipDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information );
					$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}
				if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
					return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
				}
				// catching Error
				if ($this->_isErrorEnabled ()) {
					$inputs = array (
							"GROUP_ID" => $group_id
					);
					$this->_error ( $this->_getVarDump ( $inputs ) . "activate_trial_subscriber failed!", $e );
				}
				throw $e;
			}
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "activate_trial_subscriber failed!", $e );
			}
			throw $e;
		}
	}

    /** Method to update subscriber service status
     * @param string $update_user_id
     * @param array $param_array
     * @param array $group_details
     * @return array|void
     */
	public function update_subscriber_service_access($update_user_id, $param_array, $group_details, $scheduleReport = true) {
		$response_array = array ();
		$connection = DbConnector::getConnection ();
		if ($this->_isDebugEnabled ()) {
			$this->_debug ( "Subscriberfacade -> update_subscriber_service_access -> Parameter details" );
			$this->_debug ( var_export ( $param_array, true ) );
		}
		$subscriber = SubscriberDao::get_subscriber_details_by_user_id ( $connection, $update_user_id, $group_details->group_id, "subscriber_type" );
		if (UtilityMethods::isEmpty ( $subscriber )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Invalid User Id provided..." . $update_user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::RESOURCE_NOT_EXISTS;
			return $response_array;
		}
		if (! ProvUtility::isSubscriberConfiguredOrSipTrunk ( $subscriber ["subscriber_type"] )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( "Service access status can be update only for configured/sip trunk subscribers. No operation performed for user " . $update_user_id );
			}
			return;
		}
		$old_subscriber_details = $this->_get_subscriber_details ( $connection, $update_user_id, $group_details, true );
        unset($old_subscriber_details['public_charge_id']);
		if (isset ( $old_subscriber_details ["ERROR_CODE"] )) { // Invalid Subscriber User Id
            $this->_error("Subscriber Facade -> _get_subscriber_details -> Invalid subscriber user id");
			return $old_subscriber_details;
		}

		if (UtilityMethods::is_sip_pbx_basic_menu_bundle ( $old_subscriber_details ["menu"] )) {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( "Service access status cannot be updated for sip pbx basic subscribers. No operation performed for user " . $update_user_id );
			}
			return;
		}

		if (UtilityMethods::isNotEqual ( $old_subscriber_details ["status"], ProvisioningConstant::SUBSCRIBER_STATUS_ACTIVE )) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Status is Not Active for user Id..." . $old_subscriber_details ["user_id"] );
			}
			return SubscriberValidator::build_error_message ( ApiResponseConstant::SUBSCRIBER_IS_NOT_ACTIVE, null );
		}

		try {
			if (ProvUtility::isSubscriberConfiguredOrSipTrunk ( $old_subscriber_details ["subscriber_type"] )) {
				$connection->beginTransaction ();

				$subscriber_details = array ();
				$subscriber_details ["domain"] = $group_details->top_level_domain;
				$subscriber_details ["group_id"] = $group_details->group_id;
				$subscriber_details ["user_id"] = UtilityMethods::get_subscriber_id ( $update_user_id ) . "@" . $group_details->top_level_domain;
				$subscriber_details ["subscriber_id"] = $old_subscriber_details ["subscriber_id"];
				$subscriber_details ["prov_system_id"] = $old_subscriber_details ["prov_system_id"];
				$subscriber_details ["subscriber_type"] = $old_subscriber_details ["subscriber_type"];
				$subscriber_details ["service_access_status"] = $param_array ["service_status"];
                $subscriber_details['site_id'] = $old_subscriber_details['site_id'];
                $subscriber_details['voip_alias'] = $old_subscriber_details['voip_alias'];
				$user_id = $subscriber_details ["user_id"];

				$old_menu = ProductDao::getSubscriberMenuByServiceSet ( $connection, $old_subscriber_details ["service_set_value"] );
				$site_service_information = SiteDao::get_site_service_detail_for_prov ( $connection, $group_details->group_id, $old_subscriber_details ["site_identifier"] );
				SubscriberDao::update_subscriber_service_status ( $connection, $subscriber_details );

				// acl-8234
				$mida_facade = new MidaFacade;
				if($subscriber_details["service_access_status"] == ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_INACTIVE ){
					SubscriberDao::insert_suspend_subscriber_to_record_suspend_date($connection, $subscriber_details["user_id"]);
					$prov_system_id = $subscriber_details ["prov_system_id"];
					$subscriber_details['mida_user_id'] = MidaUserDao::get_mida_user_id_by_user_id($connection,$subscriber_details ['user_id']);
		            $extension_id = MidaUserDao::get_extension_id_by_user_id($connection, $subscriber_details ['user_id']);
		            if(!empty($subscriber_details['mida_user_id'])){
                        $this->_debug("Subscriber Facade -> call delete_mida_user");
		            	$mida_facade->delete_mida_user($connection, $subscriber_details, $prov_system_id, $extension_id);
		            }
				}
				else{ // restore subscriber
					SubscriberDao::update_suspend_subscriber_log_with_active_date($connection, $subscriber_details["user_id"]);
					if(!MidaUserDao::check_exist_mida_user($connection, $old_subscriber_details['user_id'])){
						$old_subscriber_details['primary_voip_number'] = $old_subscriber_details['primary_number'];
						$sub_user_id = UtilityMethods::get_subscriber_id($old_subscriber_details ["user_id"]);
						$tenant_id = MidaTenantDao::get_tenant_info_by_group_id($connection, $old_subscriber_details['group_id'], 'tenant_id')['tenant_id'];
                        $this->_debug("Subscriber Facade -> call create_mida_user");
						$mida_facade->create_mida_user($connection, $old_subscriber_details, $tenant_id, $sub_user_id);
					}
				}

                // Perform A2 Call
                $individualProv = new Individual();

                $res_status = SubscriberDao::get_restricted_status($connection, $update_user_id);
                if ($res_status) {
                    //if its restricted, remove restriction
                    $set_restricted_value = 0;
                    SubscriberDao::set_restricted_status($connection, $set_restricted_value, $update_user_id);
                    $input_param = [];
                    $input_param['top_level_domain'] = $group_details->top_level_domain;
                    $input_param['prov_system_id'] = $old_subscriber_details['prov_system_id'];
                    $input_param['user_id'] = UtilityMethods::get_subscriber_id($update_user_id) . '@' . $group_details->top_level_domain;
                    $input_param['func'] = 'removeSystemProfileForUser_denyalloutgoingcalls';
					$individualProv->setSystemProfileForUser_denyalloutgoingcalls($connection, $input_param);
					$old_subscriber_details['service_access_status'] = strtoupper(ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_DISPLAY_CONTENT_RESTRICTED);
                }

                $response = $individualProv->modifyUser(
                    $connection,
                    $group_details,
                    $subscriber_details,
                    $site_service_information,
                    true
                );

				if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( " Subscriber Facade -> update_subscriber_service_access(modifyUser) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
					}
					$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_USER_CALL_FAILED );
				}

				if (UtilityMethods::is_nonstandalone_voicemail_related_menu_bundle ( $old_menu )) {
					$subscriber_details ["voicemail_account"] = $old_subscriber_details ["voicemail_account"];

					$response = $individualProv->findAndUpdateVoicemailStatus ( $connection, $group_details, $subscriber_details );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> _statusUpdateVoicemailDetails failed  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}

						// Roll Back modifyUser service access status
						$subscriber_details ["service_access_status"] = $old_subscriber_details ["service_access_status"];
                        $response = $individualProv->modifyUser(
                            $connection,
                            $group_details,
                            $subscriber_details,
                            $site_service_information,
                            true
                        );

						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> roll back modifyUser service access status  for user " . $subscriber_details ["user_id"] . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}
						$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_FIND_AND_UPADTE_VOICEMAIL_STATUS_CALL_FAILED );
					}
				}
                if(UtilityMethods::is_rich_messaging_menu_bundle($old_menu)){
                    $response = $individualProv->updateStatusRichMessaging($connection, $group_details, $subscriber_details);
                }
                $this->_debug("Subscriber Facade -> call AADirectorySyncFacade::syncForSingleAction");
                AADirectorySyncFacade::factory($connection)->syncForSingleAction(
                    AADirectorySyncConstant::ACTION_SOURCE_SUBSCRIBER_SERVICE_ACCESS_STATUS_UPDATE,
                    $subscriber_details
                );

				DbConnector::commitTransaction ( $connection );

				if ($scheduleReport) {
					// START - Report for Subscriber provisioning changes.
					$this->subscriber_historic_report(ReportConstants::EVENT_TYPE_UPDATE, $group_details, $subscriber_details, $old_subscriber_details);
					// END - Report for Subscriber provisioning changes.
				}
                $this->_debug("# Subscriberfacade -> update_subscriber_service_access is success -> | User status changed to " . $subscriber_details["service_access_status"] . " from " . $old_subscriber_details ["service_access_status"] . " | User id is " .  UtilityMethods::get_subscriber_id($update_user_id) . '@' . $group_details->top_level_domain);
			}
		} catch ( Exception $e ) {
			DbConnector::rollbackTransaction ( $connection );
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Update Subscriber Service Status Access Failed!", $e );
			}
			if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
				return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
			}
			return $this->_build_error_message ( ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED, "" );
		}
	}

	// end of method update_subscriber_service_access()
	public function _get_array_difference($old_detail_array, $new_detail_array, $convert_to_array, $array_delimiter = ",") {
		if ($convert_to_array) {
			$removed_items = array_diff ( explode ( $array_delimiter, $old_detail_array ), explode ( $array_delimiter, $new_detail_array ) );
			$added_items = array_diff ( explode ( $array_delimiter, $new_detail_array ), explode ( $array_delimiter, $old_detail_array ) );
		} else {
			if (! is_array ( $old_detail_array )) {
				$old_detail_array = array ();
			}
			if (! is_array ( $new_detail_array )) {
				$new_detail_array = array ();
			}
			$removed_items = array_diff ( $old_detail_array, $new_detail_array );
			$added_items = array_diff ( $new_detail_array, $old_detail_array );
		}
		$response_array = array (
				"REMOVED_ITEMS" => $removed_items,
				"ADDED_ITEMS" => $added_items
		);
		return $response_array;
	}
	private function _convert_non_provision_to_standlaone_subscriber_details($connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details) {
		$user_id = $subscriber_details ["user_id"];
		if ($this->_isDebugEnabled ()) {
			$this->_debug ( " Convert Non provision to Standalone Details for Subscriber:" . $user_id );
		}

		$this->_verify_override_options ( $subscriber_details, $site_service_information );
		return $this->_update_standalone_subscriber_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
	}

	// end of method _convert_non_provision_to_standlaone_subscriber_details()
	private function _convert_non_provision_to_configured_subscriber_details($connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details) {
		$user_id = $subscriber_details ["user_id"];
		if ($this->_isDebugEnabled ()) {
			$this->_debug ( " Convert Non Provision to Configured Subscriber for :" . $user_id );
		}
		$this->_verify_override_options ( $subscriber_details, $site_service_information );

		$old_subscriber_details ["voip_numbers"] = array ();
		$old_subscriber_details ["devices"] = array ();

        return $this->_update_configured_subscriber_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
	}

	// end of method _convert_non_provision_to_configured_subscriber_details()
	private function _subscriber_invoice_details_for_update($connection, $product_diff_array, $subscriber_details, $group_details) {
		if (ProvUtility::isDefaultStatusInActive ( $subscriber_details ["default_status"] )) {
			return;
		}
		$group_domain = $group_details->top_level_domain;
		if (UtilityMethods::isSMB ( $group_details->group_type )) {
			$group_domain = $group_details->smb_prefix . "." . $group_details->top_level_domain;
		}

		$subscriber_products = $subscriber_details ["product_ids"];
		if (count ( $product_diff_array ["REMOVED_ITEMS"] ) > 0) {
			$subscriber_details ["product_ids"] = implode ( ",", $product_diff_array ["REMOVED_ITEMS"] );
			SubscriberDao::insert_subscriber_invoice_details ( $connection, $subscriber_details, ReportConstant::SUBSCRIBER_INVOICE_REMOVED_STATUS, $group_domain, ProvUtility::getPstnDidGroupId ( $group_details ) );
		}
		if (count ( $product_diff_array ["ADDED_ITEMS"] ) > 0) {
			$subscriber_details ["product_ids"] = implode ( ",", $product_diff_array ["ADDED_ITEMS"] );
			SubscriberDao::insert_subscriber_invoice_details ( $connection, $subscriber_details, ReportConstant::SUBSCRIBER_INVOICE_ADDED_STATUS, $group_domain, ProvUtility::getPstnDidGroupId ( $group_details ) );
		}
	}
	private function _update_non_provision_subscriber_details($connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details) {
		$user_id = $subscriber_details ["user_id"];
		if ($this->_isDebugEnabled ()) {
			$this->_debug ( " Update Non Provosion Details for Subscriber:" . $user_id );
		}
		$update_param = array ();
		$product_diff_response_array = $this->_get_array_difference ( $old_subscriber_details ["product_ids"], $subscriber_details ["product_ids"], true );
		if ((count ( $product_diff_response_array ["REMOVED_ITEMS"] ) > 0) || (count ( $product_diff_response_array ["ADDED_ITEMS"] ) > 0)) {
			$update_param ["sku"] = $subscriber_details ["sku"];
			$update_param ["product_ids"] = $subscriber_details ["product_ids"];
		}
		$non_prov_fields = array (
				"site_id",
				"first_name",
				"last_name",
				"emails",
				"role",
				"default_status",
                "selected_language"
		);
		$this->_update_array_for_changes ( $subscriber_details, $old_subscriber_details, $non_prov_fields, $update_param );
		if (count ( $update_param ) > 0) {
			$update_param ["user_id"] = $subscriber_details ["user_id"];
			$update_param ["subscriber_id"] = $subscriber_details ["subscriber_id"];
			$update_param ["group_id"] = $subscriber_details ["group_id"];
			$update_param ["subscriber_type"] = $subscriber_details ["subscriber_type"];
			try {
				$connection->beginTransaction ();
				SubscriberDao::update_non_prov_subscriber ( $connection, $update_param );
				if (isset ( $update_param ["sku"] )) {
					$this->_subscriber_invoice_details_for_update ( $connection, $product_diff_response_array, $subscriber_details, $group_details );
				}
				$this->_add_remove__subscriber_notices ( $connection, $group_details->group_id );
				DbConnector::commitTransaction ( $connection );
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Update Successful for Non Provosion Details for Subscriber:" . $user_id );
				}
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Updating Details for Non provision Subscriber Failed!", $e );
				}
				$response_array ["ERROR_CODE"] = ApiResponseConstant::SAVE_SUBSCRIBER_DETAILS_FAILED;
				if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
					return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
				}
				return $response_array;
			}
		}  // end of if(count($update_param)>0)
		else {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " No changes found to Update Non Provosion Details for Subscriber:" . $user_id );
			}
		} // end of else-if(count($update_param)>0)
		return true;
	}

	// end of method _update_non_provision_subscriber_details()
	private function _update_sip_trunk_subscriber_details($connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details) {
		$user_id = $subscriber_details ["user_id"];
		if ($this->_isDebugEnabled ()) {
			$this->_debug ( " Update Sip Trunk Provision Details for Subscriber:" . $user_id );
		}
		$menu = $subscriber_details ["menu"];
		$old_menu = $old_subscriber_details ["menu"];
		$service_set_value = $subscriber_details ["service_set_value"];
		$old_service_set_value = $old_subscriber_details ["service_set_value"];

		$is_service_set_changed = UtilityMethods::isNotEqual ( $old_service_set_value, $service_set_value );

		$update_param = array ();
		$product_diff_response_array = $this->_get_array_difference ( $old_subscriber_details ["product_ids"], $subscriber_details ["product_ids"], true );
		if ((count ( $product_diff_response_array ["REMOVED_ITEMS"] ) > 0) || (count ( $product_diff_response_array ["ADDED_ITEMS"] ) > 0)) {
			$update_param ["sku"] = $subscriber_details ["sku"];
			$update_param ["product_ids"] = $subscriber_details ["product_ids"];
		}

        // Below if-block is a copy-paste fix that we don't like so much but works. Better fix would require refactoring which is out of the equation right now.
        if (
            UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($service_set_value)
            && UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($old_service_set_value)
        ) {
            $this->_update_call_recording_user(
                $connection, $service_set_value,
                $subscriber_details,
                $call_executed_list,
                $old_service_set_value
            );
        } elseif (
            !UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($service_set_value)
            && UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($old_service_set_value)
        ) {
            $this->_delete_call_recording_user($connection, $group_details, $subscriber_details, $call_executed_list);
        } elseif (
            UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($service_set_value)
            && !UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($old_service_set_value)
        ) {
            $this->_add_call_recording_user($connection, $service_set_value, $subscriber_details, $call_executed_list);
        }

		if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
			if (UtilityMethods::is_sip_pbx_basic_menu_bundle ( $old_menu )) {
				$provision_response = SubscriberValidator::pre_process_provision_details ( $connection, $subscriber_details, $group_details, NULL );
			} else {
				$provision_response = SubscriberValidator::pre_process_provision_details ( $connection, $subscriber_details, $group_details, $old_subscriber_details );
			}

			if (is_array ( $provision_response )) {
				return $provision_response;
			}
		}

		$sip_trunk_response = SubscriberValidator::pre_process_sip_trunk_details ( $connection, $subscriber_details, $group_details, $old_subscriber_details );
		if (is_array ( $sip_trunk_response )) {
			return $sip_trunk_response;
		}

		$sip_trunk_fields = array (
				"site_id",
				"first_name",
				"last_name",
				"role",
				"voip_numbers",
				"service_set_value",
				"default_status",
				"voice_mail_directory_number",
                "language"
		);
		if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu )) {
			$sip_trunk_fields = array_merge ( $sip_trunk_fields, $this->_sip_pbx_routing_fields, array (
					"timezone",
					"timezone_id",
					"password"
			) );
		}
		if (UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
			$sip_trunk_fields = array_merge ( $sip_trunk_fields, $this->_sip_pbx_calling_fields, array (
					"timezone",
					"timezone_id",
					"password"
			) );
		}
		$this->_update_array_for_changes ( $subscriber_details, $old_subscriber_details, $sip_trunk_fields, $update_param );

		$new_password = UtilityMethods::getValueFromArray ( $subscriber_details, "password", "" );
		if (isset ( $subscriber_details ["update_password_field"] ) && UtilityMethods::isNotEmpty ( $new_password )) {
			$update_param ["password"] = $new_password;
		}

		if (count ( $update_param ) > 0) {
			$update_param ["user_id"] = $subscriber_details ["user_id"];
			$update_param ["subscriber_id"] = $subscriber_details ["subscriber_id"];
			$update_param ["group_id"] = $subscriber_details ["group_id"];
			$update_param ["subscriber_type"] = $subscriber_details ["subscriber_type"];

			try {
				/*
				 * Mark PSTN in progress & Commit and update A2 with new PSTN, so other are not using it
				 * Mark Devices in progress & Commit
				 */
				$this->_reserve_prov_in_progress_data_for_update ( $connection, $group_details, $subscriber_details, $old_subscriber_details );
			} catch ( Exception $reserve_exception ) {
				$response_array ["ERROR_CODE"] = ApiResponseConstant::UNABLE_TO_ADD_SUBSCRIBER;
				return $response_array;
			}
			try {
				$connection->beginTransaction ();

				if (UtilityMethods::is_sip_pbx_basic_menu_bundle ( $menu ) && (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $old_menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $old_menu ))) {
					SubscriberDao::convert_to_sip_pbx_basic ( $connection, $subscriber_details );
				} else {
					SubscriberDao::update_sip_trunk_subscriber ( $connection, $update_param );
				}
				if (isset ( $update_param ["sku"] )) {
					$this->_subscriber_invoice_details_for_update ( $connection, $product_diff_response_array, $subscriber_details, $group_details );
				}
				$this->_add_remove__subscriber_notices ( $connection, $group_details->group_id );

				$old_subscriber_voip_number = UtilityMethods::getValueFromArray ( $old_subscriber_details, "voip_numbers", array () );
				$new_subscriber_voip_number = UtilityMethods::getValueFromArray ( $subscriber_details, "voip_numbers", array () );
				$voip_numbers_diff = $this->_get_array_difference ( $old_subscriber_voip_number, $new_subscriber_voip_number, FALSE );
				$removed_voip_numbers = $voip_numbers_diff ["REMOVED_ITEMS"];

				if (isset ( $subscriber_details ["voice_mail_directory_number"] )) {
                    PstndidDao::reset_primary_pstn_did_for_individualprov ( $connection, $subscriber_details ["subscriber_id"] );
                    PstndidDao::set_primary_pstn_did_for_individualprov ( $connection, $subscriber_details ["voice_mail_directory_number"] ); // Set Primary PSTN
				}
				if (count ( $voip_numbers_diff ["REMOVED_ITEMS"] ) > 0) {
					PstndidDao::remove_pstndid_for_existing_subscriber ( $connection, $voip_numbers_diff ["REMOVED_ITEMS"], $group_details ); // PSTN Update
				}
				if (count ( $voip_numbers_diff ["ADDED_ITEMS"] ) > 0) {
					PstndidDao::update_pstndid_for_new_subscriber ( $connection, $subscriber_details, $group_details ); // PSTN Update
				}

				$call_executed_list = array ();
				// Perform A2 Call
				$individualProv = new models\external\prov\Individual ();

				if (UtilityMethods::is_sip_pbx_basic_menu_bundle ( $old_menu ) && (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu ))) {
                    $response = $individualProv->addUser(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        $site_service_information,
                        true
                    );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> _update_sip_trunk_subscriber_details failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}
						$this->_add_user_error_response($response);
						$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED );
					}
					$call_executed_list [] = "addUser";

					if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" )) {
						$this->_saveVoipDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information );
						if (! UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
							$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						}
						$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}

					if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) || $this->_is_field_not_empty ( $subscriber_details, "public_charge_id" )) {
                        $this->_setUserChargeInfo($connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $old_subscriber_details);

						if ($group_details->number_display_option != 1) {
							$this->_setDNandNQforUser1 ( $connection, $group_details, $subscriber_details, $site_service_information, $individualProv, $call_executed_list );
						}
					}
				} elseif (UtilityMethods::is_sip_pbx_basic_menu_bundle ( $menu ) && (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $old_menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $old_menu ))) {
					$this->_deleteSubscriber ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				} elseif (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
					if (UtilityMethods::isNotEqual ( $subscriber_details ["site_id"], $old_subscriber_details ["site_id"] )) {
						$response = $individualProv->modifyUserSubdomain ( $connection, $group_details, $old_subscriber_details, $site_service_information );
						if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isDebugEnabled ()) {
								$this->_debug ( " Subscriber Facade -> _update_sip_trunk_subscriber_details(moveSingleUser) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
							}
							$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MOVE_SINGLE_USER_CALL_FAILED );
						}
						$call_executed_list [] = "moveSingleUser";
					}
					if ($is_service_set_changed) {
                        $response = $individualProv->modifyUserServiceSets(
                            $connection,
                            $group_details,
                            $subscriber_details,
                            $site_service_information,
                            $old_service_set_value,
                            true
                        );
						if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isDebugEnabled ()) {
								$this->_debug ( " Subscriber Facade -> _update_sip_trunk_subscriber_details(modifyUserServiceSets) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
							}
							$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_USER_SERVICE_SETS_CALL_FAILED );
						}
						$call_executed_list [] = "modifyUserServiceSets";
					} else {
						if (count ( array_intersect_key ( $update_param, array_fill_keys ( $this->_modify_user_fields, "" ) ) ) > 0) {
                            $response = $individualProv->modifyUser(
                                $connection,
                                $group_details,
                                $subscriber_details,
                                $site_service_information,
                                true
                            );
							if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
								if ($this->_isDebugEnabled ()) {
									$this->_debug ( " Subscriber Facade -> _update_sip_trunk_subscriber_details(modifyUser) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
								}
								$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_USER_CALL_FAILED );
							}
							$call_executed_list [] = "modifyUser";
						}
					}

					$new_password = UtilityMethods::getValueFromArray ( $subscriber_details, "password", "" );
					if (isset ( $subscriber_details ["update_password_field"] ) && UtilityMethods::isNotEmpty ( $new_password )) {
						$response = $individualProv->changePassword ( $connection, $group_details, $subscriber_details );
						if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isDebugEnabled ()) {
								$this->_debug ( " Subscriber Facade -> _update_sip_trunk_subscriber_details(changePassword) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
							}
							if (preg_match('/Invalid Password. Password must have at least (.*) capital (.*)/i', $response [ProvisioningConstant::A2_RESPONSE])) {
								throw new CallFailedException("", ApiResponseConstant::CHANGE_USER_PASSWORD_INVALID_PASSWORD_CAPITAL_LETTER);
							}
							$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_CHANGE_USER_PASSWORD_CALL_FAILED );
						}
						$call_executed_list [] = "changeUserPassword";
					}

					if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" )) {
						if (isset ( $update_param ["voice_mail_directory_number"] ) || count ( $voip_numbers_diff ["ADDED_ITEMS"] ) > 0 || count ( $voip_numbers_diff ["REMOVED_ITEMS"] ) > 0) {
							$this->_saveVoipDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information );
						}
					} else if ($this->_is_field_not_empty ( $old_subscriber_details, "voip_numbers" )) { // Remove directory number if voip number is empty
						$removeDiectory_response = $individualProv->removeUserDirectoryNumber1 ( $connection, $group_details, $subscriber_details );
						if (UtilityMethods::isNotEqual ( $removeDiectory_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isDebugEnabled ()) {
								$this->_debug ( " Subscriber Facade -> _update_sip_trunk_subscriber_details(removeUserDirectoryNumber1) failed  for user " . $user_id . " response is " . $removeDiectory_response [ProvisioningConstant::A2_RESPONSE] );
							}
							$this->_check_translated_response ( $removeDiectory_response, ApiResponseConstant::SUBSCRIBER_REMOVE_USER_DIRECTORY_NUMBER_CALL_FAILED );
						}
						$call_executed_list [] = "removeUserDirectoryNumber1";
					}

					if (UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu ) && UtilityMethods::is_sip_pbx_routing_menu_bundle ( $old_menu )) {
						$this->_removeCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					} elseif (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) && UtilityMethods::is_sip_pbx_calling_menu_bundle ( $old_menu )) {
						$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					} else if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) && (isset ( $update_param ["call_forward_permission"] ) || isset ( $update_param ["call_permission"] ))) {
						$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}

					if (isset ( $update_param ["location_name"] )) {
						$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}

					if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) || $this->_is_field_not_empty ( $subscriber_details, "public_charge_id" )) {
						if (isset ( $update_param ["public_charge_id"] ) || (UtilityMethods::isEmpty ( $subscriber_details ["public_charge_id"] ) && isset ( $update_param ["voice_mail_directory_number"] ))) {
                            $this->_setUserChargeInfo($connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $old_subscriber_details);
						}
					} else if (isset ( $old_subscriber_details ['public_charge_id'] ) && isset ( $old_subscriber_details ['voice_mail_directory_number'] ) && $old_subscriber_details ['public_charge_id'] == $old_subscriber_details ['voice_mail_directory_number']) {
                        // $this->_removeUserChargeInfo ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}
				}

				if (count ( $voip_numbers_diff ["ADDED_ITEMS"] ) > 0 || count ( $voip_numbers_diff ["REMOVED_ITEMS"] ) > 0) {
					// Reset In progress to disable
					$voip_numbers = array_merge ( $voip_numbers_diff ["ADDED_ITEMS"], $voip_numbers_diff ["REMOVED_ITEMS"] );
					if (count ( $voip_numbers ) > 0) {
						PstndidDao::reset_pstndid_for_provision_in_progress ( $connection, $voip_numbers, ProvUtility::getPstnDidGroupId ( $group_details ) );
					}
				}

				if (($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) && count ( $subscriber_details ["voip_numbers"] ) > 0)) {
					$this->_associate_subscriber_to_pbx( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details, $call_executed_list );
				} else if ($this->_is_field_not_empty ( $old_subscriber_details, "voip_numbers" ) && $this->_is_field_empty ( $subscriber_details, "voip_numbers" )) {
					$this->_associate_subscriber_to_pbx( $connection, NULL, $group_details, $site_service_information, $old_subscriber_details, $call_executed_list );
				}

				DbConnector::commitTransaction ( $connection );
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Update Successful for sip trunk Provision Details for Subscriber:" . $user_id );
				}
			} catch ( Exception $e ) {
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Updating Details for sip trunk provision Subscriber Failed!", $e );
				}
				/*
				 * On Failure to update subscriber, perform the following rollbacks
				 * 1. Rollback user updated in A2 before vacant update, so PSTN can be re-assigned to vacant users.
				 * 2. Cancel PSTN Did that was marked as in progress and update vacant pstn did in A2
				 */
				$this->_rollback_update_subscriber_details ( $connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details );
				DbConnector::rollbackTransaction ( $connection );
				// This function has been moved to rollback_update_subscriber_details
				//$this->_reset_prov_in_progress_data_for_update ( $connection, $group_details, $subscriber_details, $old_subscriber_details );

				if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
					return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
				}
				return SubscriberValidator::build_error_message ( ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED, null );
			}
		}  // end of if(count($update_param)>0)
		else {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " No changes found to Update sip trunk Details for Subscriber:" . $user_id );
			}
		} // end of else-if(count($update_param)>0)
		return true;
	}

	// end of method _update_non_provision_subscriber_details()
	private function _update_configured_subscriber_details($connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details) {
		$user_id = $subscriber_details ["user_id"];
		if ($this->_isDebugEnabled ()) {
			$this->_debug ( " Update Configured Details for Subscriber:" . $user_id );
		}
        $this->_verify_override_options($subscriber_details, $site_service_information);
		$service_set_value = $subscriber_details ["service_set_value"];
		$old_service_set_value = $old_subscriber_details ["service_set_value"];
		$menu = $subscriber_details ["menu"];
		$old_menu = $old_subscriber_details ["menu"];

		$is_service_set_changed = UtilityMethods::isNotEqual ( $old_service_set_value, $service_set_value );

		$new_changed_service_sets = $this->_get_array_difference($old_service_set_value, $service_set_value, true, "|");
		$new_changed_service_sets = implode('|', array_merge ( $new_changed_service_sets["ADDED_ITEMS"], $new_changed_service_sets["REMOVED_ITEMS"] ));
		$new_changed_a2_service_sets = UtilityMethods::get_a2_services($connection, $new_changed_service_sets);
		// To check incompatible service for call answer on product change
		if (ProvUtility::isSubscriberConfigured ( $old_subscriber_details ["subscriber_type"] ) && UtilityMethods::isNotEmpty($new_changed_a2_service_sets)) {
			$call_routing_facade = new CallRoutingFacade ();
			$call_group_service_set_array = $call_routing_facade->get_call_groups_service_by_subscriber ( $user_id, $group_details->group_id );
			$this->_debug ( "Subscriber call answer group services : " . $this->_getVarDump ( $call_group_service_set_array ) );
			if (count ( $call_group_service_set_array ) > 0) {
				$acc_service_sets = explode ( '|', $service_set_value );
				$service_set_services = $call_routing_facade->get_services_for_service_sets ( $acc_service_sets );
				if (UtilityMethods::isNotEmpty($service_set_services)) {
					$this->_debug ( "Subscriber new services : " . $this->_getVarDump ( $service_set_services ) );
					if (is_array ( $call_group_service_set_array ['REQUIRED_SERVICES'] ) && count ( $call_group_service_set_array ['REQUIRED_SERVICES'] ) > 0) {
						$compare_services = array_intersect ( $service_set_services, $call_group_service_set_array ['REQUIRED_SERVICES'] );
						if (is_array ( $compare_services ) && count ( $compare_services ) == 0) {
							return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_CALL_ANSWER_GROUP_AGENT_SERVICE_SET_CANNOT_MODIFIED, "" );
						}
					}
					if (is_array ( $call_group_service_set_array ['INCOMPATIBLE_SERVICES'] ) && count ( $call_group_service_set_array ['INCOMPATIBLE_SERVICES'] ) > 0) {
						$compare_services = array_intersect ( $service_set_services, $call_group_service_set_array ['INCOMPATIBLE_SERVICES'] );
						if (is_array ( $compare_services ) && count ( $compare_services ) > 0) {
							return $this->_build_error_message ( ApiResponseConstant::SUBSCRIBER_CALL_ANSWER_GROUP_AGENT_SERVICE_SET_CANNOT_MODIFIED, "" );
						}
					}
				}
			}
		}

		$update_param = array ();

		$product_diff_response_array = $this->_get_array_difference ( $old_subscriber_details ["product_ids"], $subscriber_details ["product_ids"], true );
		if ((count ( $product_diff_response_array ["REMOVED_ITEMS"] ) > 0) || (count ( $product_diff_response_array ["ADDED_ITEMS"] ) > 0)) {
			$update_param ["sku"] = $subscriber_details ["sku"];
			$update_param ["product_ids"] = $subscriber_details ["product_ids"];
		}

		if (UtilityMethods::isEmpty ( $old_service_set_value )) {
			$provision_response = SubscriberValidator::pre_process_provision_details ( $connection, $subscriber_details, $group_details, NULL );
		} else {
			$provision_response = SubscriberValidator::pre_process_provision_details ( $connection, $subscriber_details, $group_details, $old_subscriber_details );
		}
		if (is_array ( $provision_response )) {
			return $provision_response;
		}

        // Check the KBS_APICONSUMER service set is available
        if (!UtilityMethods::is_kbs_api_consumer_service_bundle($subscriber_details["service_set_value"])
            || (UtilityMethods::is_kbs_api_consumer_service_bundle($subscriber_details["service_set_value"])
                && UtilityMethods::is_VoIP_number_not_empty($subscriber_details["voip_numbers"]))) {
            if (UtilityMethods::isEmpty($old_service_set_value)) {
                $VoIPResponse = SubscriberValidator::preProcessVoIPDetails(
                    $connection,
                    $subscriber_details,
                    $group_details,
                    $site_service_information,
                    null
                );
            } else {
                $VoIPResponse = SubscriberValidator::preProcessVoIPDetails(
                    $connection,
                    $subscriber_details,
                    $group_details,
                    $site_service_information,
                    $old_subscriber_details
                );
            }
            if (is_array($VoIPResponse) && array_key_exists('ERROR_CODE', $VoIPResponse)) {
                return $VoIPResponse;
            }
        }

		if (UtilityMethods::isEmpty ( $old_service_set_value )) {
			$client_response = SubscriberValidator::pre_process_client_details ( $connection, $subscriber_details, $group_details, $site_service_information, NULL );
		} else {
			$client_response = SubscriberValidator::pre_process_client_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
		}
		if (is_array ( $client_response )) {
			return $client_response;
		}


		if (UtilityMethods::isEmpty ( $old_service_set_value )) {
			$livesupport_response = SubscriberValidator::pre_process_livesupport_details ( $connection, $subscriber_details, $group_details, $site_service_information, NULL );
		} else {
			$livesupport_response = SubscriberValidator::pre_process_livesupport_details ( $connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details );
		}
		if (is_array ( $livesupport_response )) {
			return $livesupport_response;
		}

		if (isset ( $old_subscriber_details ["voicemail_service"] ) && ProvUtility::isVoicemailServiceHostedOrPermise ( $old_subscriber_details ["voicemail_service"] )) {
			if (! UtilityMethods::is_voicemail_menu_bundle ( $menu )) {
				$subscriber_details ["voicemail_service"] = ProvisioningConstant::VOICEMAIL_SERVER_NONE;
				// Here use string(null), if we use null then subscriberdao::_build_update_query_and_param() could not identify it
				$update_param ["voicemail_service"] = "NULL";
			}
		}

        if (UtilityMethods::is_voicemail_menu_bundle($menu) && !$this->fromMigration) {
            if (!UtilityMethods::is_nonstandalone_voicemail_related_menu_bundle($old_menu)) {
                $voicemail_response = SubscriberValidator::pre_process_voicemail_details($connection, $subscriber_details, $group_details, null);
            } else {
                $voicemail_response = SubscriberValidator::pre_process_voicemail_details($connection, $subscriber_details, $group_details, $old_subscriber_details);
            }
            if (is_array($voicemail_response)) {
                return $voicemail_response;
            }
        } // end of if(voicemail SS)
		if (UtilityMethods::is_meetme_menu_bundle ( $menu )) {
			if (UtilityMethods::isEmpty ( $old_service_set_value ) || ! isset ( $old_subscriber_details ["voip_numbers"] ) || count ( $old_subscriber_details ["voip_numbers"] ) == 0) {
				$meetme_response = SubscriberValidator::pre_process_meetme_details ( $connection, $subscriber_details, $group_details, NULL );
			} else {
				$meetme_response = SubscriberValidator::pre_process_meetme_details ( $connection, $subscriber_details, $group_details, $old_subscriber_details );
			}
			if (is_array ( $meetme_response )) {
				return $meetme_response;
			}
		} // end of if (SS is MeetMe)
		if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu )) {
            if (UtilityMethods::isEmpty($old_service_set_value)) {
				$smartoffice_response = SubscriberValidator::pre_process_smart_office_details ( $connection, $subscriber_details, $group_details, null );
			} else {
				$smartoffice_response = SubscriberValidator::pre_process_smart_office_details ( $connection, $subscriber_details, $group_details, $old_subscriber_details );
			}

			if (is_array ( $smartoffice_response )) {
				return $smartoffice_response;
			}
		} // end of if (SS is SmatOffice Screen Share)
		if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
            if (UtilityMethods::isEmpty($old_service_set_value)) {
				$smartoffice_response = SubscriberValidator::pre_process_smart_office_details ( $connection, $subscriber_details, $group_details, null );
			} else {
				$smartoffice_response = SubscriberValidator::pre_process_smart_office_details ( $connection, $subscriber_details, $group_details, $old_subscriber_details );
			}

			if (is_array ( $smartoffice_response )) {
				return $smartoffice_response;
			}
		} // end of if (SS is SmatOffice Video Share)
		if (UtilityMethods::is_ipscape_menu_bundle ( $menu )) {
			$ipscape_response = IpScapeValidator::pre_process_ipscape_details ( $connection, $group_details );

			if (is_array ( $ipscape_response )) {
				return $ipscape_response;
			}
		} // end of IPSCAPE if
		if (UtilityMethods::is_mida_menu_bundle ( $menu )) {
			$mida_response = MidaValidator::pre_process_mida_details ( $connection, $group_details );
			if (is_array ( $mida_response )) {
				return $mida_response;
			}
		} // end of MIDA if

		$commonFields = [
				'first_name',
				'last_name',
				'password',
				'device_password',
				'service_set_value',
				'site_id',
				'emails',
				'role',
				'sso_auth_user_id',
				'authentication_method',
				'timezone',
				'timezone_id',
				'voip_numbers',
				'default_status',
                'voice_mail_directory_number',
                'department'
        ];

		$configured_fields = array_merge($commonFields, $this->_voip_fields);
		if (UtilityMethods::is_nonstandalone_voicemail_related_menu_bundle ( $menu )) {
			$configured_fields = array_merge ( $configured_fields, $this->_voicemail_fields );
		}
		if (UtilityMethods::is_meetme_menu_bundle ( $menu )) {
			$configured_fields = array_merge ( $configured_fields, $this->_meetme_fields );
		}
		if (UtilityMethods::is_callgrab_menu_bundle ( $menu )) {
			$configured_fields = array_merge ( $configured_fields, $this->_callgrab_fields );
		}
		if (UtilityMethods::is_mobility_menu_bundle ( $menu )) {
			$configured_fields = array_merge ( $configured_fields, $this->_mep_fields );
		}
		if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu ) || UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
			$configured_fields = array_merge ( $configured_fields, $this->_smart_office_fields );
		}
		$this->_update_array_for_changes ( $subscriber_details, $old_subscriber_details, $configured_fields, $update_param );

		// clear removed ss fields
		if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $old_menu ) || UtilityMethods::is_smart_office_video_collab_menu_bundle ( $old_menu )) {
			if (! UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu ) && ! UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
				$update_param ["conference_extn_number"] = "NULL";
			}
		}

		$new_password = UtilityMethods::getValueFromArray ( $subscriber_details, "password", "" );
		if (isset ( $subscriber_details ["update_password_field"] ) && UtilityMethods::isNotEmpty ( $new_password )) {
			$update_param ["password"] = $new_password;
			$update_param["last_updated_password_stamp"] = UtilityMethods::getCurrentTime();
			$this->_debug('Subscriber password was changed for subscriber = ' . $user_id);
		}

		$new_device_password = UtilityMethods::getValueFromArray ( $subscriber_details, "device_password", "" );
		if (isset ( $subscriber_details ["update_device_password_field"] ) && UtilityMethods::isNotEmpty ( $new_device_password )) {
			$update_param ["device_password"] = $new_device_password;
			$update_param["last_updated_pmc_password_stamp"] = UtilityMethods::getCurrentTime();
			$this->_debug('Subscriber pmc password was changed for subscriber = ' . $user_id);
		}

		if ($group_details->number_display_option == 3 && UtilityMethods::is_contact_center_menu_bundle ( $subscriber_details ["menu"] ) && UtilityMethods::isNotEqual ( $subscriber_details ["campaign_number"], $old_subscriber_details ["campaign_number"] )) {
			$update_param ["campaign_number"] = $subscriber_details ["campaign_number"];
		}

		if (! empty ( $subscriber_details ['client_type'] ) && UtilityMethods::isNotEqual ( $subscriber_details ["client_type"], $old_subscriber_details ["client_type"] )) {
			$update_param ["client_type_id"] = ClientConfigurationDao::get_catalog_client_id_by_type ( $connection, $subscriber_details ["client_type"] ) ['client_type_id'];
		}
		if (empty ( $subscriber_details ['client_type'] )) {
			$update_param ["client_type_id"] = "NULL";
		}

        if(isset($subscriber_details['language'])) {
            $update_param["language"] = $subscriber_details["language"];
        } else if(isset($subscriber_details['selected_language'])) {
            $update_param['language'] = $subscriber_details['selected_language'];
        }

        if($update_param['language'] == null || empty($update_param['language'])) {
            $update_param['language'] = 'en';
        }

        $this->_printLogForUpdateParams($update_param);

		if (count ( $update_param ) > 0) {
			$update_param ["user_id"] = $subscriber_details ["user_id"];
			$update_param ["subscriber_id"] = $subscriber_details ["subscriber_id"];
			$update_param ["group_id"] = $subscriber_details ["group_id"];
			$update_param ["subscriber_type"] = $subscriber_details ["subscriber_type"];

            if (isset($subscriber_details['msg_ip_address'])) {
                $update_param['msg_ip_address'] = $subscriber_details['msg_ip_address'];
            } elseif (UtilityMethods::isNotEmpty($site_service_information['sesm_name'])) {
                $sesmProfile = SesmProfileDao::get_sesm_profile_details(
                    $connection,
                    $subscriber_details['prov_system_id'],
                    $site_service_information['sesm_name']);
                if (UtilityMethods::isNotEmpty($sesmProfile)) {
                    $update_param['msg_ip_address'] = $sesmProfile['ip_address'];
                }
            }

			if (ProvUtility::isVoicemailServiceNotNone ( UtilityMethods::getValueFromArray ( $old_subscriber_details, "voicemail_service", "" ) ) && ProvUtility::isVoicemailServiceNone ( UtilityMethods::getValueFromArray ( $subscriber_details, "voicemail_service", "" ) )) {
				// Here use string(null), if we use null then subscriberdao::_build_update_query_and_param() could not identify it
				$update_param ["voicemail_server"] = "NULL";
				$update_param ["voicemail_number"] = "NULL";
				$update_param ["voicemail_pin"] = "NULL";
				$update_param ["voicemail_notification"] = ProvisioningConstant::VOICEMAIL_NOTIFICATION_OFF;
				$update_param ["msg_ip_address"] = "NULL";
			} elseif (ProvUtility::isVoicemailServicePermise ( UtilityMethods::getValueFromArray ( $subscriber_details, "voicemail_service", "" ) )) {
				$update_param ["voicemail_pin"] = "NULL";
				$update_param ["voicemail_notification"] = ProvisioningConstant::VOICEMAIL_NOTIFICATION_OFF;
			} elseif (ProvUtility::isVoicemailServiceHosted ( UtilityMethods::getValueFromArray ( $subscriber_details, "voicemail_service", "" ) )) {
				$update_param ["voicemail_number"] = "NULL";
			}

			$old_state = UtilityMethods::getValueFromArray ( $old_subscriber_details, "device_password_state" );
			$new_state = UtilityMethods::getValueFromArray ( $subscriber_details, "device_password_state" );
			if (ProvUtility::isValidDevicePasswordStateNone ( $new_state ) && ProvUtility::isValidDevicePasswordStateNotNone ( $old_state )) {
				$update_param ["device_password"] = "NULL";
				$update_param["last_updated_pmc_password_stamp"] = UtilityMethods::getCurrentTime();
				$this->_debug('Subscriber pmc password state was changed for subscriber = ' . $user_id);
			} elseif (ProvUtility::isValidDevicePasswordStateSite($new_state) && ProvUtility::isValidDevicePasswordStateNone($old_state)) {
				$update_param["last_updated_pmc_password_stamp"] = UtilityMethods::getCurrentTime();
				$this->_debug('Subscriber pmc password state was changed for subscriber = ' . $user_id);
			} elseif (ProvUtility::isValidDevicePasswordStateSite($new_state) && ProvUtility::isValidDevicePasswordStateUser($old_state)) {
				$update_param["last_updated_pmc_password_stamp"] = UtilityMethods::getCurrentTime();
				$this->_debug('Subscriber pmc password state was changed for subscriber = ' . $user_id);
			} elseif (ProvUtility::isValidDevicePasswordStateNone($new_state) && ProvUtility::isValidDevicePasswordStateUser($old_state)) {
				$update_param["device_password"] = "NULL";
				$update_param["last_updated_pmc_password_stamp"] = UtilityMethods::getCurrentTime();
				$this->_debug('Subscriber pmc password state was changed for subscriber = ' . $user_id);
			}
			$call_executed_list = array ();

            if (UtilityMethods::is_voicemail_menu_bundle($menu)) {
                if ($this->_is_field_empty($subscriber_details, "voicemail_account")) {
                    if (!$this->fromMigration) {
                        $generated_number = $this->_generate_voicemail_account($connection);
                        $subscriber_details ["voicemail_account"] = $generated_number;
                        $update_param ["voicemail_account"] = $generated_number;
                    } else {
                        $update_param ["voicemail_account"] = $subscriber_details ["voicemail_account"];
                    }
                } else {
                    if ($this->fromMigration) {
                        $update_param ["voicemail_account"] = $subscriber_details["voicemail_account"];
                    }
                }
            } // end of if(SS is VM)
			if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu ) || UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu )) {
				if ($this->_is_field_empty ( $subscriber_details, "smart_office_proxy_id" )) {
					$collab_type = ProvisioningConstant::SMART_OFFICE_VIDEO_COLLAB;
					if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu )) {
						$collab_type = ProvisioningConstant::SMART_OFFICE_WEB_COLLAB;
					}
					$smart_office_group_id = $this->_get_smart_office_group_id ( $group_details );
					$smart_office_proxy_id = $this->get_smart_office_proxy_detail ( $connection, $smart_office_group_id, $collab_type );
					$subscriber_details ["smart_office_proxy_id"] = $smart_office_proxy_id ["proxy_id"];
					$update_param ["smart_office_proxy_id"] = $smart_office_proxy_id ["proxy_id"];
				}
			}

			try {
				/*
				 * Mark PSTN in progress & Commit and update A2 with new PSTN, so other are not using it
				 * Mark Devices in progress & Commit
				 */
				$this->_reserve_prov_in_progress_data_for_update ( $connection, $group_details, $subscriber_details, $old_subscriber_details );
			} catch ( Exception $reserve_exception ) {
				$response_array ["ERROR_CODE"] = ApiResponseConstant::UNABLE_TO_ADD_SUBSCRIBER;
				return $response_array;
			}


			try {
				$connection->beginTransaction ();

                if (
                    $this->_is_field_not_empty($subscriber_details, "product_ids")
                    && !UtilityMethods::is_standalone_voicemail_menu_bundle($menu)
                ) {
                    $psxFacade = new PSXFacade();
                    $psxFacade->validateNumbers($subscriber_details ["product_ids"], $group_details->group_id);
                }

                if ($this->_isApiConsumerOrApiCallMeServiceBundle($service_set_value)
                    || $this->_isApiConsumerOrApiCallMeServiceBundle($old_service_set_value)) {

                    $update_param['destination'] = $subscriber_details['destination'];
                    $update_param['force_tokenized_identity'] = $subscriber_details['force_tokenized_identity'];
                    $update_param['call_me_auth_token_id'] = $subscriber_details['call_me_auth_token_id'];
                    $updateApiConsumerSubscriberCallExecutedList = $this->_updateApiConsumerSubscriber(
                        $connection,
                        $group_details,
                        $is_service_set_changed,
                        $subscriber_details,
                        $old_subscriber_details
                    );
                    $call_executed_list = array_merge($call_executed_list, $updateApiConsumerSubscriberCallExecutedList);
                }

				//Update live support subscriber
				$passwordAlreadyUpdatedByLiveSupportAPI = false;
                if (UtilityMethods::is_livesupport_service_bundle($service_set_value) || UtilityMethods::is_livesupport_service_bundle($old_service_set_value)) {
                    $update_live_support = $this->_update_live_support_subscriber($connection, $group_details, $is_service_set_changed, $service_set_value, $old_service_set_value, $subscriber_details, $old_subscriber_details);
                    if (array_key_exists("ERROR_CODE", $update_live_support)) {
                        if ($this->_isErrorEnabled()) {
                            $this->_error("Unable to update Live Support user.");
                        }
                        $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                        return $update_live_support;
                    }
                    $passwordAlreadyUpdatedByLiveSupportAPI = UtilityMethods::isNotEqual($subscriber_details['is_ls_request'] ?? 0, 1);
                    if ($passwordAlreadyUpdatedByLiveSupportAPI) {
                        $this->_debug(
                            'SubscriberFacade -> _update_configured_subscriber_details password change already ' .
                            'triggered by live support API. No need to run a new password change.'
                        );
                    }
                }
				$call_executed_list[] = 'UpdateLiveSupportSubscriber';

                // SSO Auth user id update Start
                $ssoFacade = new SsoFacade();
                $groupSsoAccessDetails = $ssoFacade->checkGroupSSOAccess($group_details->group_id, SsoConstant::SUBSCRIBER_SSO);
                // Check Access
                if ($groupSsoAccessDetails['access']) {
                    // Update if auth user id or password changed
                    if (UtilityMethods::isNotEqualValue($subscriber_details['sso_auth_user_id'],
                            $old_subscriber_details['sso_auth_user_id'])
                        || UtilityMethods::isNotEqualValue($subscriber_details['user_password'],
                            $old_subscriber_details['user_password'])) {

                        // Delete user if auth user id is empty
                        if (UtilityMethods::isEmpty($subscriber_details['sso_auth_user_id'])) {
                            $deleteKeycloakUserResponse = $ssoFacade->deleteKeycloakUser($connection, $group_details,
                                $old_subscriber_details, SsoConstant::SUBSCRIBER_SSO);
                            if (UtilityMethods::isNotEmpty($deleteKeycloakUserResponse['ERROR_CODE'])) {
                                if ($this->_isErrorEnabled()) {
                                    $this->_error('Unable to delete Keycloak User.');
                                }
                                $this->_rollback_update_subscriber_details($connection, $group_details,
                                    $subscriber_details, $call_executed_list, $old_subscriber_details);
                                return $deleteKeycloakUserResponse;
                            }
                            $call_executed_list[] = 'deleteKeycloakSubscriber';
                        } else {
                            // Update keycloak user
                            $updateKeycloakUserResponse = $ssoFacade->updateKeycloakUser($connection, $group_details,
                                $subscriber_details, $old_subscriber_details, SsoConstant::SUBSCRIBER_SSO);

                            if (UtilityMethods::isNotEmpty($updateKeycloakUserResponse['ERROR_CODE'])) {
                                if ($this->_isErrorEnabled()) {
                                    $this->_error('Unable to delete Keycloak User.');
                                }
                                $this->_rollback_update_subscriber_details($connection, $group_details,
                                    $subscriber_details, $call_executed_list, $old_subscriber_details);
                                return $updateKeycloakUserResponse;
                            }
                            $call_executed_list[] = 'updateKeycloakSubscriber';
                        }
                    }

                    $update_param['sso_auth_user_id'] = $subscriber_details['sso_auth_user_id'];
                }
                // SSO Auth user id update End

				/*
				 * Perform all DB update before sending A2 Calls
				 */

				if (UtilityMethods::isEmpty ( $old_service_set_value ) || UtilityMethods::is_standalone_voicemail_menu_bundle ( $old_menu )) {
					SubscriberDao::update_subscriber_type ( $connection, $subscriber_details );
				}
				SubscriberDao::update_configured_subscriber ( $connection, $update_param );
				if (isset ( $update_param ["sku"] ) && ! isset ( $subscriber_details ["rollback_operation"] )) {
					$this->_subscriber_invoice_details_for_update ( $connection, $product_diff_response_array, $subscriber_details, $group_details );
				}
				$this->_add_remove__subscriber_notices ( $connection, $group_details->group_id );

                // Then, we need to set callgrab_number to empty so we can update call grabber details
                if (
                    UtilityMethods::is_callgrab_menu_bundle($menu)
                    && $this->fromMigration
                    && (
                        empty($subscriber_details['callgrab_number'])
                        || $subscriber_details['callgrab_number'] === 'NULL'
                    )
                ) {
                    $update_param['callgrab_number'] = '';
                    $subscriber_details['callgrab_number'] = '';
                }

				// ACL-1854
				// 1) old and new have CONTACT_CENTER menu, but campaign_number has changed. Modify campaign_number and update contact_center_people.
				// 2) old had no CONTACT_CENTER and new has CONTACT_CENTER. Insert into contact_center_people and create new campaign_number.
				// 3) old had CONTACT_CENTER and new has no CONTACT_CENTER. Delete record from contact_center_people and remove campaign_number.
				if ($group_details->number_display_option == 3) {
					if ((isset ( $update_param ["campaign_number"] ) || isset ( $update_param ["voice_mail_directory_number"] )) && UtilityMethods::is_contact_center_menu_bundle ( $old_menu ) && UtilityMethods::is_contact_center_menu_bundle ( $menu )) {
						if (UtilityMethods::isEqual ( $old_subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true ) && UtilityMethods::isNotEqual ( $subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
							$this->_debug ( "Inserting campaign number ..." );
							$this->insert_contact_center_people_campaign_number ( $connection, $group_details, $subscriber_details );
						} else if (UtilityMethods::isNotEqual ( $old_subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true ) && UtilityMethods::isEqual ( $subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
							$this->_debug ( "Deleting campaign number ..." );
							ContactCenterPeopleDao::delete_people_by_subscriber ( $connection, $subscriber_details ["subscriber_id"], $group_details->group_id );
						} else if ((isset ( $update_param ["campaign_number"] ) || isset ( $update_param ["voice_mail_directory_number"] )) && UtilityMethods::isNotEqual ( $subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
							$this->_debug ( "Updating campaign number ..." );
							$this->update_contact_center_people_campaign_number ( $connection, $group_details, $subscriber_details );
						}
					} else if (isset ( $update_param ["campaign_number"] ) && ! UtilityMethods::is_contact_center_menu_bundle ( $old_menu ) && UtilityMethods::is_contact_center_menu_bundle ( $menu )) {
						$this->_debug ( "Inserting campaign number ..." );
						$this->insert_contact_center_people_campaign_number ( $connection, $group_details, $subscriber_details );
					} else if (UtilityMethods::is_contact_center_menu_bundle ( $old_menu ) && ! UtilityMethods::is_contact_center_menu_bundle ( $menu ) && UtilityMethods::isNotEqual ( $old_subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
						$this->_debug ( "Deleting campaign number ..." );
						ContactCenterPeopleDao::delete_people_by_subscriber ( $connection, $subscriber_details ["subscriber_id"], $group_details->group_id );
					}
				}

				$old_subscriber_voip_number = UtilityMethods::getValueFromArray ( $old_subscriber_details, "voip_numbers", array () );
				$new_subscriber_voip_number = UtilityMethods::getValueFromArray ( $subscriber_details, "voip_numbers", array () );
				$voip_numbers_diff = $this->_get_array_difference ( $old_subscriber_voip_number, $new_subscriber_voip_number, FALSE );

				if (isset ( $subscriber_details ["voice_mail_directory_number"] )) {
					pstndiddao::reset_primary_pstn_did_for_individualprov ( $connection, $subscriber_details ["subscriber_id"] );
					pstndiddao::set_primary_pstn_did_for_individualprov ( $connection, $subscriber_details ["voice_mail_directory_number"] ); // Set Primary PSTN
				}

                if (!empty($voip_numbers_diff ["REMOVED_ITEMS"])) {
                    PstndidDao::remove_pstndid_for_existing_subscriber($connection, $voip_numbers_diff ["REMOVED_ITEMS"], $group_details); // PSTN Update
                }
                if (!empty($voip_numbers_diff ["ADDED_ITEMS"])) {
                    PstndidDao::update_pstndid_for_new_subscriber($connection, $subscriber_details, $group_details); // PSTN Update
                }

				if (! isset ( $old_subscriber_details ["devices"] )) {
					$old_subscriber_details ["devices"] = array ();
				}
				if (! isset ( $subscriber_details ["devices"] )) {
					$subscriber_details ["devices"] = array ();
				}
				$devices_diff = $this->_get_array_difference ( $old_subscriber_details ["devices"], $subscriber_details ["devices"], FALSE );
				if (count ( $devices_diff ["REMOVED_ITEMS"] ) > 0) {
					$devices_valid = TerminalsDao::check_devices_available_for_group($connection, $devices_diff["REMOVED_ITEMS"], $group_details->group_id, "removed");
					$generic_devices_valid = GenericDeviceDao::check_generic_devices_available_for_group($connection, $devices_diff["REMOVED_ITEMS"], $group_details->group_id, "removed");
					$devices_valid = array_column($devices_valid, 'mac_address');
					$generic_devices_valid = array_column($generic_devices_valid, 'mac_address');
					if(count($devices_valid) > 0){
						TerminalsDao::remove_devices_for_subscriber($connection, $devices_valid, $group_details->group_id );
					}
					if(count($generic_devices_valid) > 0){
						GenericDeviceDao::remove_generic_devices_for_subscriber ( $connection, $generic_devices_valid, $group_details->group_id );
					}
					foreach ($devices_diff ["REMOVED_ITEMS"] as $removed_device){
						SyncDeviceStatusDao::delete($connection, $removed_device);
					}
					foreach ($devices_diff ["REMOVED_ITEMS"] as $removed_device){
						RegistrationDeviceStatusDao::delete_by_mac($connection, $removed_device);
					}
				}
				if (count ( $devices_diff ["ADDED_ITEMS"] ) > 0) {
					$devices_valid = TerminalsDao::check_devices_available_for_group($connection, $devices_diff["ADDED_ITEMS"], $group_details->group_id);
					$generic_devices_valid = GenericDeviceDao::check_generic_devices_available_for_group($connection, $devices_diff["ADDED_ITEMS"], $group_details->group_id);
					$devices_valid = array_column($devices_valid, 'mac_address');
					$generic_devices_valid = array_column($generic_devices_valid, 'mac_address');
					if(count($devices_valid) > 0){
						TerminalsDao::assign_devices_for_subscriber($connection, $devices_valid, $group_details->group_id, $old_subscriber_details["subscriber_id"]);
					}
					if(count($generic_devices_valid) > 0){
						GenericDeviceDao::assign_generic_devices_for_subscriber($connection, $generic_devices_valid, $group_details->group_id, $old_subscriber_details ["subscriber_id"]);
					}
				}

				/* Update Business Continuity Order Status Starts */
				if (UtilityMethods::is_bcpremium_bundle ( $old_service_set_value ) && ! UtilityMethods::is_bcpremium_bundle ( $service_set_value )) {
					$this->remove_subscriber_business_continuity_status ( $connection, $group_details->group_id, 1 );
				}

				if (! UtilityMethods::is_bcpremium_bundle ( $old_service_set_value ) && UtilityMethods::is_bcpremium_bundle ( $service_set_value )) {
					$this->add_subscriber_business_continuity_status ( $connection, $group_details->group_id );
				}
				/* Update Business Continuity Order Status Ends */

                if($subscriber_details ["voicemail_emails"] == 'enabled' && isset($subscriber_details ["email"])) {
                    $subscriber_details ["voicemail_notification"] = ProvisioningConstant::VOICEMAIL_NOTIFICATION_ALWAYS;
                }

				// Perform A2 Call
				$individualProv = new models\external\prov\Individual ();
				$mas_response_array = array ();
				if ($is_service_set_changed && UtilityMethods::is_meetme_menu_bundle ( $old_menu ) && UtilityMethods::is_meetme_menu_bundle ( $menu )) {
					/*
					 * if both old and new service set has meetme then
					 * get chair person details,since "modifyUserSets" will reset those details.
					 * Once "modifyUserSets" is completed, call "setUserProfile_MeetMeSPAdminService" with old details.
					 */

					$mas_paramater = array (
							'user' => $subscriber_details ["user_id"]
					);
					$mas_response = $this->get_provision_response_by_url ( MAS_URL, $mas_paramater, NULL );
					if ($this->_isDebugEnabled ()) {
						$this->_debug ( "Subscriber Facade -> _update_configured_subscriber_details -> MAS URL response is   " . $mas_response );
					}
					$mas_response_array = json_decode ( $mas_response, true );
				}

				if (UtilityMethods::isEmpty ( $old_service_set_value ) || UtilityMethods::is_standalone_voicemail_menu_bundle ( $old_menu )) {
                    $response = $individualProv->addUser(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        $site_service_information,
                        true
                    );
					if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> save_subscriber_details failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
						}
						$this->_add_user_error_response($response);
						$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED );
					}
					$call_executed_list [] = "addUser";
				} else {
					if (UtilityMethods::isNotEqual ( $subscriber_details ["site_id"], $old_subscriber_details ["site_id"] )) {
						$call_routing_facade = new CallRoutingFacade ();
						if(!@$_GET['skipCAG'])
						    $call_routing_group_list = $call_routing_facade->get_call_routing_group_list ( $connection, $group_details, $subscriber_details ["user_id"] );
						$response = $individualProv->modifyUserSubdomain ( $connection, $group_details, $old_subscriber_details, $site_service_information );
						if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isDebugEnabled ()) {
								$this->_debug ( " Subscriber Facade -> _update_configured_subscriber_details(moveSingleUser) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
							}
							$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MOVE_SINGLE_USER_CALL_FAILED );
						} else {
                            $group_details->prov_system_id = $subscriber_details['prov_system_id'];
                            $this->updateSubscriberPasswordAfterSiteMove($connection, (array)$group_details, $subscriber_details);
                        }
						$call_executed_list [] = "moveSingleUser";

                        $response = $individualProv->modifyVoicemail($connection, $group_details, $subscriber_details);
                        if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                            if ($this->_isDebugEnabled()) {
                                $this->_debug('Subscriber Facade -> _update_configured_subscriber_details(modifyVoicemail) failed  for user ' . $user_id .
                                     ' response is ' . $response[ProvisioningConstant::A2_RESPONSE]);
                            }
                        }
                        $call_executed_list[] = 'modifyVoicemail';
                        if(!@$_GET['skipCAG'])
                            $response = $call_routing_facade->re_add_subscriber_call_routing_group ( $connection, $subscriber_details ["user_id"], $call_routing_group_list, $group_details );
						if (is_array ( $response ) && array_key_exists ( 'ERROR_CODE', $response )) {
							throw new CallFailedException ( "", $response ['ERROR_CODE'] );
						}
					}
					if ($is_service_set_changed) {
						// Remove call for smart office web & video before modify service set
						$old_so_video = false;
						$old_so_screen_share = false;
						if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $old_menu ) && $this->_is_field_not_empty ( $old_subscriber_details, "conference_extn_number" )) {
							$old_so_video = true;
						}
						if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $old_menu ) && $this->_is_field_not_empty ( $old_subscriber_details, "conference_extn_number" )) {
							$old_so_screen_share = true;
						}

						$so_video = false;
						$so_screen_share = false;

						if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu ) && $this->_is_field_not_empty ( $subscriber_details, "conference_extn_number" )) {
							$so_video = true;
						}
						if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu ) && $this->_is_field_not_empty ( $subscriber_details, "conference_extn_number" )) {
							$so_screen_share = true;
						}

						if ($old_so_video && ! $so_video) {
							$this->_removeUserProfile_VideoCollabAdminService ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						}
						if ($old_so_screen_share && ! $so_screen_share) {
							$this->_removeUserProfile_WebCollabAdminService ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						}
						if ( UtilityMethods::isNotEmpty($new_changed_a2_service_sets)) {
							// Update $subscriber_details["timezone"] with timezone->a2.  Restore $subscriber_details after the Prov call.
							$timezone_info = TimezoneDao::get_timezone_details_by_name($connection,$subscriber_details["timezone"]);
                            $response = $individualProv->modifyUserServiceSets(
                                $connection,
                                $group_details,
                                $subscriber_details,
                                $site_service_information,
                                $old_service_set_value,
                                true
                            );
							if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
								if ($this->_isDebugEnabled ()) {
									$this->_debug ( " Subscriber Facade -> _update_configured_subscriber_details(modifyUserServiceSets) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
								}
								$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_USER_SERVICE_SETS_CALL_FAILED );
							}
							$call_executed_list [] = "modifyUserServiceSets";
						}
					}
						if (count ( array_intersect_key ( $update_param, array_fill_keys ( $this->_modify_user_fields, "" ) ) ) > 0) {
                            $response = $individualProv->modifyUser(
                                $connection,
                                $group_details,
                                $subscriber_details,
                                $site_service_information,
                                true
                            );
							if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
								if (strpos($response[ProvisioningConstant::A2_RESPONSE], ProvisioningConstant::PROVISIONING_SUCCESS_MSG) === false && strpos($response[ProvisioningConstant::A2_RESPONSE], 'Characters (",\) cannot be used') !== false){
									$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_VALIDATOR_FOR_SPECIAL_CHARACTER);
								}
								if ($this->_isDebugEnabled ()) {
									$this->_debug ( " Subscriber Facade -> _update_configured_subscriber_details(modifyUser) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
								}
								$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_MODIFY_USER_CALL_FAILED );
							}
							$call_executed_list [] = "modifyUser";
						}


					if ($is_service_set_changed && UtilityMethods::is_meetme_menu_bundle ( $old_menu ) && UtilityMethods::is_meetme_menu_bundle ( $menu )) {
						if (is_array ( $mas_response_array ) && count ( $mas_response_array ) > 0) {
							if (isset ( $mas_response_array ["age"] ) && $mas_response_array ["age"] <= CHAIR_PIN_IGNORE_MAX_AGE) {
								$subscriber_details ["meetme_access_code"] = $mas_response_array ["e_accessCode"];
								$subscriber_details ["meetme_pin"] = $mas_response_array ["e_pin"];

								$response = $individualProv->setMeetmeDetails ( $connection, $group_details, $subscriber_details );
								if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
									if ($this->_isDebugEnabled ()) {
										$this->_debug ( " Subscriber Facade -> _update_configured_subscriber_details(setUserProfile_MeetMeSPAdminService) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
									}
									$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_SET_USER_PROFILE_MEETME_SP_ADMIN_SERVICE_CALL_FAILED );
								} else {
									Dao::updateBasedOnGivenKey ( $connection, "subscriber_service_details", array (
											"subscriber_id" => $subscriber_details ["subscriber_id"]
									), array (
											"meetme_access_code" => $subscriber_details ["meetme_access_code"],
											"meetme_pin" => $subscriber_details ["meetme_pin"]
									) );
								}
								$call_executed_list [] = "setUserProfile_MeetMeSPAdminService";
							}
						}
					}

					$new_password = UtilityMethods::getValueFromArray ( $subscriber_details, "password", "" );
                    if (!$passwordAlreadyUpdatedByLiveSupportAPI && isset($subscriber_details["update_password_field"]) && UtilityMethods::isNotEmpty($new_password)) {
						$response = $individualProv->changePassword ( $connection, $group_details, $subscriber_details );
						if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isDebugEnabled ()) {
								$this->_debug ( " Subscriber Facade -> _update_configured_subscriber_details(changePassword) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
							}
							if(strpos($response [ProvisioningConstant::A2_RESPONSE], ProvisioningConstant::SUBSCRIBER_CHANGES_PASSWORD_FAILED_MSG ) !== false){
								$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_CHANGES_PASSWORD_SAME_AS_THE_PREVIOUS_ONE );
							}else if(preg_match("/changeUserPassword(.*)ProvisioningException(.*?)Invalid Password(.*)Password must have at least (.*) special character/i", $response [ProvisioningConstant::A2_RESPONSE])){

								//This line gets required special character count from A2 response, $special_character_count[1]
								preg_match('/at least(.*?)special/', $response [ProvisioningConstant::A2_RESPONSE], $special_character_count);

								$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_CHANGE_USER_PASSWORD_CHANGE_SPECIAL_FAILED, $special_character_count[1]);
							} else{
                                throw new CallFailedException(
                                    substr($response [ProvisioningConstant::A2_RESPONSE],
                                        strpos($response [ProvisioningConstant::A2_RESPONSE], 'Invalid Password')
                                    ),
                                    ApiResponseConstant::TRANSLATED_ERROR_MESSAGE
                                );
                            }
						}
						$call_executed_list [] = "changeUserPassword";
					}
				}

				$this->_saveOrResetDevicePassword ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information, $old_subscriber_details );

				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" )) {
					if (isset ( $update_param ["voice_mail_directory_number"] ) || count ( $voip_numbers_diff ["ADDED_ITEMS"] ) > 0 || count ( $voip_numbers_diff ["REMOVED_ITEMS"] ) > 0 || isset ( $update_param ["is_mobile_extension_enabled"] ) || (ProvUtility::isSubscriberMepExtensionEnabled ( $subscriber_details ) && isset ( $update_param ["mobile_number"] ))) {

						if (ProvUtility::isSubscriberMepExtensionEnabled ( $old_subscriber_details )) {
							$removeExtension_response = $individualProv->removeMobileExtensionUserData ( $connection, $group_details, $subscriber_details );
							if (UtilityMethods::isNotEqual ( $removeExtension_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
								if ($this->_isDebugEnabled ()) {
									$this->_debug ( " Subscriber Facade -> _update_configured_subscriber_details(removeMobileExtensionUserData) failed  for user " . $user_id . " response is " . $removeExtension_response [ProvisioningConstant::A2_RESPONSE] );
								}
								$this->_check_translated_response ( $removeExtension_response, ApiResponseConstant::SUBSCRIBER_REMOVE_MOBILE_EXTENSION_USER_DATA_CALL_FAILED );
							}
							$call_executed_list [] = "removeMobileExtensionUserData";
						}
						$this->_saveVoipDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $site_service_information );
					}
				}

				if (isset ( $update_param ["call_permission"] ) || isset ( $update_param ["call_forward_permission"] )) {
					$this->_setCosForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}

				if (isset ( $update_param ["location_name"] )) {
					$this->_setLocationForUser1 ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}
				// Remove directory number if voip number is empty
				if ($this->_is_field_empty ( $subscriber_details, "voip_numbers" ) && $this->_is_field_not_empty ( $old_subscriber_details, "voip_numbers" )) {
					if ($group_details->number_display_option != 1) {
						$response = $individualProv->removeDNandNQforUser1 ( $connection, $group_details, $subscriber_details );
						if (UtilityMethods::isNotEqual ( $response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
							if ($this->_isDebugEnabled ()) {
								$this->_debug ( " Subscriber Facade -> _saveVoipDetails(removeDNandNQforUser1) failed  for user " . $user_id . " response is " . $response [ProvisioningConstant::A2_RESPONSE] );
							}
							$this->_check_translated_response ( $response, ApiResponseConstant::SUBSCRIBER_REMOVE_DN_AND_NQ_USER_CALL_FAILED );
						}
						$call_executed_list [] = "removeDNandNQforUser1";
					}
					$removeDiectory_response = $individualProv->removeUserDirectoryNumber1 ( $connection, $group_details, $subscriber_details );
					$subscriber_details['primary_number'] = '';
					$subscriber_details['primary_voip_number'] = $subscriber_details['primary_number'];
                    $response = $individualProv->modifyUser(
                        $connection,
                        $group_details,
                        $subscriber_details,
                        $site_service_information,
                        true
                    );

					if (UtilityMethods::isNotEqual ( $removeDiectory_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
						if ($this->_isDebugEnabled ()) {
							$this->_debug ( " Subscriber Facade -> _saveVoipDetails(removeUserDirectoryNumber1) failed  for user " . $user_id . " response is " . $removeDiectory_response [ProvisioningConstant::A2_RESPONSE] );
						}
						$this->_check_translated_response ( $removeDiectory_response, ApiResponseConstant::SUBSCRIBER_REMOVE_USER_DIRECTORY_NUMBER_CALL_FAILED );
					}
					$call_executed_list [] = "removeUserDirectoryNumber1";

					if (UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu )) {
						$this->_removeUserProfile_WebCollabAdminService ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}

					if (UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu ) && (empty ( $subscriber_details ["conference_extn_number"] ) || UtilityMethods::isEqual ( substr ( $old_subscriber_details ["voice_mail_directory_number"], - 10 ), $subscriber_details ["conference_extn_number"] ))) {
						$this->_removeUserProfile_VideoCollabAdminService ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}
				}

				if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) || $this->_is_field_not_empty ( $subscriber_details, "public_charge_id" )) {
					if (isset ( $update_param ["public_charge_id"] ) || isset ( $update_param ["voice_mail_directory_number"] )) {
                        $this->_setUserChargeInfo($connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $old_subscriber_details);

						if ($group_details->number_display_option != 1) {
							$this->_setDNandNQforUser1 ( $connection, $group_details, $subscriber_details, $site_service_information, $individualProv, $call_executed_list );
						}
					}
				} else if ((isset ( $update_param ["public_charge_id"] ) && UtilityMethods::isEmpty ( $update_param ["public_charge_id"] )) || (UtilityMethods::isEmpty ( $subscriber_details ["public_charge_id"] ) && isset ( $update_param ["voice_mail_directory_number"] ))) {
					// $this->_removeUserChargeInfo ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}
                if (isset($update_param['voip_alias'])) {
                    try {
                        $subscribersUserIds = SubscriberDao::getSubscribersByGroupId(
                            $connection,
                            $group_details->group_id
                        );
                        foreach ($subscribersUserIds as $userIds) {
                            $userId = strstr($userIds['user_id'], '@', true);
                            if(UtilityMethods::isEqual($update_param['voip_alias'], $userId)){
                                $response_array['ERROR_CODE'] = ApiResponseConstant::SUBSCRIBER_ID_ALIAS_MATCHES;
                                return $response_array;
                            }
                        }
                    } catch (Exception $e) {
                            $this->_error('Getting User IDs Failed!', $e);
                    }
					$this->_updateUserAlias ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				}  elseif (!isset($update_param['voip_alias']) && isset($old_subscriber_details['voip_alias']) && $old_subscriber_details['voip_alias'] != '') {
                    $subscriber_details['voip_alias'] = $old_subscriber_details['voip_alias'];
                    $this->_updateUserAlias($connection, $group_details, $subscriber_details, $individualProv,$call_executed_list);
                }

				if (UtilityMethods::is_voicemail_menu_bundle ( $menu ) && isset ( $subscriber_details ["voicemail_service"] )) {
					/*
					 * If Voicemail Service is changed from Hosted -> NONE/PERMISE then
					 * delete the voicemail account & remove user voicemail server
					 * else if old and new voicemail account is Hosted then
					 * send Modify A2 Request & set user voicemail server
					 * else if voicemail service is changed from NONE/PERMISE -> Hosted then
					 * create voicemail account & set user voicemail server
					 * else if voicemail service is changed from NONE/PERMISE -> PERMISE then
					 * set user voicemail server
					 * else // old and new voicemail account is None/Permise
					 * No A2 Request
					 */

					if (! isset ( $old_subscriber_details ["voicemail_service"] )) {
						$old_subscriber_details ["voicemail_service"] = ProvisioningConstant::VOICEMAIL_SERVER_NONE;
					}

					if (ProvUtility::isVoicemailServiceHosted ( $old_subscriber_details ["voicemail_service"] ) && ProvUtility::isVoicemailServicePermiseOrNone ( $subscriber_details ["voicemail_service"] )) {
						$this->_deleteVoicemailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						if (ProvUtility::isVoicemailServicePermise ( $subscriber_details ["voicemail_service"] )) {
							$this->_setUsersVoicemailServer ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						}
					} else if (ProvUtility::isVoicemailServiceHosted ( $old_subscriber_details ["voicemail_service"] ) && ProvUtility::isVoicemailServiceHosted ( $subscriber_details ["voicemail_service"] )) {

						/**
						 * ACL-1611 Changing subscriber product from business fax to auto attendent does not update offer on CIM
						 * Need to treat voicemail, autoattendant and business fax as different services.
						 * f there is a change from one of the services to another, we need to delete the old account on the VM server and create the new account with the new service
						 */
						if ((UtilityMethods::is_nonstandalone_voicemail_menu_bundle ( $old_menu ) && UtilityMethods::is_non_standalone_auto_attendant_menu_bundle ( $menu )) || (UtilityMethods::is_nonstandalone_voicemail_menu_bundle ( $old_menu ) && UtilityMethods::is_business_fax_menu_bundle ( $menu )) || (UtilityMethods::is_non_standalone_auto_attendant_menu_bundle ( $old_menu ) && UtilityMethods::is_business_fax_menu_bundle ( $menu )) || (UtilityMethods::is_non_standalone_auto_attendant_menu_bundle ( $old_menu ) && UtilityMethods::is_nonstandalone_voicemail_menu_bundle ( $menu )) || (UtilityMethods::is_business_fax_menu_bundle ( $old_menu ) && UtilityMethods::is_non_standalone_auto_attendant_menu_bundle ( $menu )) || (UtilityMethods::is_business_fax_menu_bundle ( $old_menu ) && UtilityMethods::is_nonstandalone_voicemail_menu_bundle ( $menu ))) {
							$this->_deleteVoicemailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
							$this->_saveVoicemailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						} else {
							if ($is_service_set_changed || count ( array_intersect_key ( $update_param, array_fill_keys ( $this->_modify_hosted_voicemail_fields, "" ) ) ) > 0) {
								// As per JIRA ACL-785 If the user leaves the v_VMpin empty on a modify, simply dont send v_VMpin, the backend will leave their pin alone.
								$update_subscriber_details = $subscriber_details;
								if (! isset ( $update_param ["voicemail_pin"] )) {
									unset ( $update_subscriber_details ["voicemail_pin"] );
								}
								$this->_updateVoicemailDetails ( $connection, $group_details, $update_subscriber_details, $individualProv, $call_executed_list);

								if (ProvUtility::isUreachDeviceType ( $group_details->voice_mail_device_type )) {
									$paProv = new models\external\prov\pa\Pa ();
									$response = $paProv->SetPhoneSettings ( $connection, $subscriber_details );
									if (is_string ( $response [ProvisioningConstant::A2_RESPONSE] ) && ! preg_match ( "/Failed/i", $response [ProvisioningConstant::A2_RESPONSE] )) {
										$call_executed_list [] = "SetPhoneSettings";
									}
								}
							}
						}
					} else if (ProvUtility::isVoicemailServicePermiseOrNone ( $old_subscriber_details ["voicemail_service"] ) && ProvUtility::isVoicemailServiceHosted ( $subscriber_details ["voicemail_service"] )) {
						$this->_saveVoicemailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					} else if (ProvUtility::isVoicemailServicePermiseOrNone ( $old_subscriber_details ["voicemail_service"] ) && ProvUtility::isVoicemailServicePermise ( $subscriber_details ["voicemail_service"] )) {
						if (ProvUtility::isVoicemailServiceNone ( $old_subscriber_details ["voicemail_service"] ) || count ( array_intersect_key ( $update_param, array_fill_keys ( $this->_modify_premise_voicemail_fields, "" ) ) ) > 0) {
							$this->_setUsersVoicemailServer ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						}
					} else if (ProvUtility::isVoicemailServicePermise ( $old_subscriber_details ["voicemail_service"] ) && ProvUtility::isVoicemailServiceNone ( $subscriber_details ["voicemail_service"] )) {
						$this->_removeUsersVoicemailServer ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}
				} elseif (UtilityMethods::is_voicemail_menu_bundle($old_menu)) {
					$this->_deleteVoicemailDetails($connection, $group_details, $subscriber_details, $individualProv, $call_executed_list);
                    if (
                        UtilityMethods::is_rich_messaging_service_bundle($old_subscriber_details['service_set_value'])
                    ) {
                        $modifyRichMessagingAccountServers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR ."|" .ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                        $subscriber_details ["voicemail_account"] = "";
                        $update_richmsg=$individualProv->modifyRichMessagingAccount($connection, $group_details, $subscriber_details, $modifyRichMessagingAccountServers);
                    }
                }else if(UtilityMethods::is_voicemail_menu_bundle ( $menu ) && !isset ( $subscriber_details ["voicemail_service"] )){
                    if ($this->_isDebugEnabled ()) {
                        $this->_debug ( "Enter a Voicemail Service ");
                    }
                    $response ["ERROR_CODE"] = ApiResponseConstant::SUBSCRIBER_VOICEMAIL_SERVICE_NULL;
                    $this->_rollback_save_subscriber_details($connection, $group_details, $subscriber_details, $site_service_information, $call_executed_list);
                    return $response;
                } // end of else-if(old SS=Voicemail)

				if (UtilityMethods::is_meetme_menu_bundle ( $menu )) {
					if ($this->_is_field_not_empty ( $subscriber_details, "meetme_access_code" ) || $this->_is_field_not_empty ( $subscriber_details, "voip_numbers" )) {
						if (isset ( $update_param ["meetme_access_code"] ) || isset ( $update_param ["meetme_pin"] ) || (isset ( $update_param ["voice_mail_directory_number"] ) && UtilityMethods::isEmpty ( $subscriber_details ["meetme_access_code"] )) || (isset ( $update_param ["voice_mail_directory_number"] ) && UtilityMethods::isEmpty ( $subscriber_details ["meetme_pin"] )) || (! UtilityMethods::is_meetme_menu_bundle ( $old_menu ) && UtilityMethods::is_meetme_menu_bundle ( $menu ))) {
							$this->_saveMeetmeDetails ( $connection, $group_details, $subscriber_details, $old_subscriber_details, $individualProv, $call_executed_list );
						}
					} else if ($this->_is_field_not_empty ( $old_subscriber_details, "meetme_access_code" ) && $this->_is_field_not_empty ( $old_subscriber_details, "voice_mail_directory_number" ) && $old_subscriber_details ['meetme_access_code'] == $old_subscriber_details ['voice_mail_directory_number']) {
						$this->_removeMeetMeDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}
				} // end of if(ss==Meet Me)

				$this->_saveSmartOfficeDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list, $old_subscriber_details, $is_service_set_changed );

				if (UtilityMethods::is_callgrab_menu_bundle ( $menu )) { // Call Grabber
					if (isset ( $update_param ["callgrab_number"] )) {
						$this->_saveCallgrabberDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}
				} elseif (UtilityMethods::is_callgrab_menu_bundle ( $old_menu ) && ! UtilityMethods::is_callgrab_menu_bundle ( $menu )) {
					$subscriber_details ["callgrab_number"] = "";
					$this->_saveCallgrabberDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				} // end of if(ss==CallGrabber)

				if (UtilityMethods::is_mobility_menu_bundle ( $menu )) { // MEP
					$call_save_mep_details = TRUE;
					if (ProvUtility::isSubscriberMepExtensionEnabled ( $old_subscriber_details ) && ProvUtility::isSubscriberMepExtensionDisabled ( $subscriber_details )) {
						$this->_disableMepExtensionDetails ( $connection, $group_details, $old_subscriber_details, $individualProv, $call_executed_list );
					} else if (ProvUtility::isSubscriberMepExtensionDisabled ( $old_subscriber_details ) && ProvUtility::isSubscriberMepExtensionEnabled ( $subscriber_details )) {
						$this->_enableMepExtensionDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					} else if (ProvUtility::isSubscriberMepExtensionEnabled ( $old_subscriber_details ) && ProvUtility::isSubscriberMepExtensionEnabled ( $subscriber_details ) && $this->_is_field_not_empty ( $old_subscriber_details, "mobile_number" ) && $this->_is_field_not_empty ( $subscriber_details, "mobile_number" )) {
						if (UtilityMethods::isNotEqual ( $old_subscriber_details ["mobile_number"], $subscriber_details ["mobile_number"] )) {
							$this->_modifyMepExtensionDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
						} else {
							$call_save_mep_details = FALSE;
						}
					} else {
						$call_save_mep_details = FALSE;
					}
					if ($call_save_mep_details || isset ( $update_param ["mobility_profile"] )) {
						$this->_saveMepDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
					}
				}  // end of if(SS==MEP)
				else if (UtilityMethods::is_mobility_menu_bundle ( $old_menu )) {
					/*
					 * If Old has MEP profile and new one does not have MEP
					 * 1. If old has MEP Extension Enabled, then disable MEP Extension
					 * 2. set mac only profile
					 */
					if (ProvUtility::isSubscriberMepExtensionEnabled ( $old_subscriber_details )) {
						$this->_disableMepExtensionDetails ( $connection, $group_details, $old_subscriber_details, $individualProv, $call_executed_list );
					}
					// To set MAC_ONLY Profile for the user
					$this->_saveMepDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				} // end of else-if(old SS==MEP)

                if (
                    UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($service_set_value)
                    && UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($old_service_set_value)
                ) {
                    $updateCallRecordingUser = $this->_update_call_recording_user(
                        $connection,
                        $service_set_value,
                        $subscriber_details,
                        $call_executed_list,
                        $old_service_set_value
                    );

                    if (array_key_exists("ERROR_CODE", $updateCallRecordingUser)) {
                        return $this->_build_error_message($updateCallRecordingUser["ERROR_CODE"], "");
                    }
                } elseif (
                    !UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($service_set_value)
                    && UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($old_service_set_value)
                ) {
                    $this->_delete_call_recording_user($connection, $group_details, $subscriber_details, $call_executed_list);
                } elseif (
                    UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($service_set_value)
                    && !UtilityMethods::isCallRecordingOrLiveSupportCallRecordingServiceBundle($old_service_set_value)
                ) {
                    $this->_add_call_recording_user($connection, $service_set_value, $subscriber_details, $call_executed_list);
                }

                // sfdc update check
                if (UtilityMethods::isSoForSfdcSubscriberBundle($service_set_value)
                    && UtilityMethods::isSoForSfdcSubscriberBundle($old_service_set_value)
                    && (UtilityMethods::isNotEqual($old_subscriber_details['settings']['sfdc_email'], $subscriber_details['sfdc_email'])
                        || UtilityMethods::isNotEqual($old_subscriber_details['voip_numbers'], $subscriber_details['voip_numbers'])
                        || UtilityMethods::isNotEqual($old_subscriber_details['voip_alias'], $subscriber_details['voip_alias']))) {

                    if (!isset($subscriber_details['sfdc_email'])) {
                        $subscriber_details['sfdc_email'] = $old_subscriber_details['settings']['sfdc_email'];
                    }

                    $sfdcFacade = new SfdcFacade();

                    $updateResponse = $sfdcFacade->updateSubscriber(
                        $connection,
                        $subscriber_details['user_id'],
                        $subscriber_details['sfdc_email'],
                        $subscriber_details ['voip_numbers'],
                        $subscriber_details['voip_alias']
                    );

                    if (array_key_exists('ERROR_CODE', $updateResponse)) {
                        $this->_rollback_update_subscriber_details(
                            $connection,
                            $group_details,
                            $subscriber_details,
                            $call_executed_list,
                            $old_subscriber_details
                        );
                        $this->_error("SubscriberFacade -> _update_configured_subscriber_details -> Unable to update Salesforce user.");
                        return $this->_build_error_message(
                            $updateResponse['ERROR_CODE'], $updateResponse['ERROR_MESSAGE']);
                    }
                    $call_executed_list[] = "updateSFDCSubscriber";
                    $sfdcFacade->sendSfdcEmailNotification("Update", $group_details, $subscriber_details, "");
                } elseif (!UtilityMethods::isSoForSfdcSubscriberBundle($service_set_value)
                    && UtilityMethods::isSoForSfdcSubscriberBundle($old_service_set_value)) {

                    if (!isset($subscriber_details['sfdc_email'])) {
                        $subscriber_details['sfdc_email'] = $old_subscriber_details['settings']['sfdc_email'];
                    }

                    $sfdcFacade = new SfdcFacade();

                    $deleteResponse = $sfdcFacade->deleteSubscriber(
                        $connection,
                        $subscriber_details['user_id'],
                        $subscriber_details['sfdc_email'],
                        $subscriber_details ['voip_numbers'],
                        $subscriber_details['voip_alias']
                    );

                    if (array_key_exists('ERROR_CODE', $deleteResponse)) {
                        $this->_rollback_update_subscriber_details(
                            $connection,
                            $group_details,
                            $subscriber_details,
                            $call_executed_list,
                            $old_subscriber_details
                        );
                        $this->_error("SubscriberFacade -> _update_configured_subscriber_details -> Unable to delete Salesforce user.");
                        return $deleteResponse;
                    }
                    $call_executed_list[] = "updateSFDCSubscriber";
                    $sfdcFacade->sendSfdcEmailNotification("Delete", $group_details, $subscriber_details, "");
                } elseif (UtilityMethods::isSoForSfdcSubscriberBundle($service_set_value)
                    && !UtilityMethods::isSoForSfdcSubscriberBundle($old_service_set_value)) {

                    if (!isset($subscriber_details['sfdc_email'])) {
                        $subscriber_details['sfdc_email'] = $old_subscriber_details['settings']['sfdc_email'];
                    }

                    $sfdcFacade = new SfdcFacade();

                    $saveResponse = $sfdcFacade->saveSubscriber(
                        $connection,
                        $subscriber_details ["group_id"],
                        $subscriber_details['user_id'],
                        $subscriber_details['sfdc_email'],
                        $subscriber_details ['voip_numbers'],
                        $subscriber_details['voip_alias']
                    );

                    if (array_key_exists('ERROR_CODE', $saveResponse)) {
                        $this->_rollback_update_subscriber_details(
                            $connection,
                            $group_details,
                            $subscriber_details,
                            $call_executed_list,
                            $old_subscriber_details
                        );
                        $this->_error("SubscriberFacade -> _update_configured_subscriber_details -> Unable to add Salesforce user.");
                        return $saveResponse;
                    }
                    $call_executed_list[] = "updateSFDCSubscriber";
                    $sfdcFacade->sendSfdcEmailNotification("Add", $group_details, $subscriber_details, "");
                }


				if (count ( $devices_diff ["ADDED_ITEMS"] ) > 0) {
					$unistim_provision_response = $this->_process_unistim_device_provisioning ( $connection, $subscriber_details, $group_details, TRUE, $devices_diff ["ADDED_ITEMS"] );
					if (! $unistim_provision_response) {
						throw new RuntimeException ( "Unistim provisioning failed" );
					}
				}

				if (count ( $devices_diff ["REMOVED_ITEMS"] ) > 0) {
					$unistim_provision_response = $this->_process_unistim_device_provisioning ( $connection, $subscriber_details, $group_details, FALSE, $devices_diff ["REMOVED_ITEMS"] );
					if (! $unistim_provision_response) {
						throw new RuntimeException ( "Unistim provisioning failed" );
					}
				}

				if (count ( $voip_numbers_diff ["ADDED_ITEMS"] ) > 0 || count ( $voip_numbers_diff ["REMOVED_ITEMS"] ) > 0) {
					// Reset In progress to disable
					$voip_numbers = array_merge ( $voip_numbers_diff ["ADDED_ITEMS"], $voip_numbers_diff ["REMOVED_ITEMS"] );
					PstndidDao::reset_pstndid_for_provision_in_progress ( $connection, $voip_numbers, ProvUtility::getPstnDidGroupId ( $group_details ) );
				}

				if ($is_service_set_changed) {
					$this->update_call_services ( $connection, UtilityMethods::toObject ( $subscriber_details ) );
				}

				// ACL-1854
				// Add/remove/modify campaign_number on SBC.
				// 1) old and new have CONTACT_CENTER menu, but campaign_number has changed. Modify campaign_number and update contact_center_people.
				// 2) old had no CONTACT_CENTER and new has CONTACT_CENTER. Insert into contact_center_people and create new campaign_number.
				// 3) old had CONTACT_CENTER and new has no CONTACT_CENTER. Delete record from contact_center_people and remove campaign_number.
				if ($group_details->number_display_option == 3) {
					if ((isset ( $update_param ["campaign_number"] ) || isset ( $update_param ["voice_mail_directory_number"] )) && UtilityMethods::is_contact_center_menu_bundle ( $old_menu ) && UtilityMethods::is_contact_center_menu_bundle ( $menu )) {
						if (UtilityMethods::isEqual ( $old_subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true ) && UtilityMethods::isNotEqual ( $subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true ))
							$this->_add_campaign_number ( $connection, $subscriber_details ["campaign_number"], $subscriber_details, $call_executed_list );
						else if (UtilityMethods::isNotEqual ( $old_subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true ) && UtilityMethods::isEqual ( $subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true ))
							$this->_remove_campaign_number ( $connection, $subscriber_details ["campaign_number"], $subscriber_details, $call_executed_list );
						else if ((isset ( $update_param ["campaign_number"] ) || isset ( $update_param ["voice_mail_directory_number"] ) && UtilityMethods::isNotEqual ( $subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )))
							$this->_modify_campaign_number ( $connection, $subscriber_details ["campaign_number"], $subscriber_details, $call_executed_list );
					} else if (isset ( $update_param ["campaign_number"] ) && ! UtilityMethods::is_contact_center_menu_bundle ( $old_menu ) && UtilityMethods::is_contact_center_menu_bundle ( $menu )) {
						$this->_add_campaign_number ( $connection, $subscriber_details ["campaign_number"], $subscriber_details, $call_executed_list );
					} else if (UtilityMethods::is_contact_center_menu_bundle ( $old_menu ) && ! UtilityMethods::is_contact_center_menu_bundle ( $menu ) && UtilityMethods::isNotEqual ( $old_subscriber_details ["campaign_number"], ContactCenterConstant::PEOPLE_CAMPAIGN_NUMBER_NONE, true )) {
						$this->_remove_campaign_number ( $connection, $subscriber_details ["campaign_number"], $subscriber_details, $call_executed_list );
					}
				}

				if (UtilityMethods::is_livesupport_service_bundle( $service_set_value ) && (! UtilityMethods::is_livesupport_service_bundle ( $old_service_set_value ) || UtilityMethods::isNotEqual($subscriber_details['password'], $old_subscriber_details['password']) ||
						UtilityMethods::isNotEqual($subscriber_details['site_id'], $old_subscriber_details['site_id']))) {
					$ls_version = LiveSupportDao::get_company_details_by_group_id($connection, $group_details->group_id, "live_support_version");
					if (UtilityMethods::isEqual($ls_version, ProvisioningConstant::LIVE_SUPPORT_KBS_VERSION)) {
						//update agent password on pa
						$pa = new Pa();
						$parameter = array("password"=>UtilityMethods::sip_data_out($subscriber_details['password']));
						$pa->changePassword($connection, $subscriber_details, $parameter);
					}
				}

                if ($this->_isApiConsumerOrApiCallMeServiceBundle($service_set_value)
                    && (!$this->_isApiConsumerOrApiCallMeServiceBundle($old_service_set_value)
                        || UtilityMethods::isNotEqual($subscriber_details['password'], $old_subscriber_details['password'])
                        || UtilityMethods::isNotEqual($subscriber_details['site_id'], $old_subscriber_details['site_id']))) {

                    //update subscriber password on pa
                    $pa = new Pa();
                    $parameter = array("password" => UtilityMethods::sip_data_out($subscriber_details['password']));
                    $pa->changePassword($connection, $subscriber_details, $parameter);

                }

				//Update kandy subscriber
				$kandy_response = $this->_update_kandy_subscriber ( $connection, $group_details, $is_service_set_changed, $service_set_value, $old_service_set_value, $subscriber_details, $old_subscriber_details );
				if (array_key_exists ( "ERROR_CODE", $kandy_response)) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Unable to update Kandy user." );
					}
					$this->_rollback_update_subscriber_details ( $connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details );
					return $kandy_response;
				}

                // VM overlay subscribers do not have SPIDR accounts created
                if (UtilityMethods::isNotEqual($subscriber_details ['site_type'], SiteConstant::SITE_TYPE_VMOVERLAY)) {
                    // Update OMNI client subscriber
                    $updateOMNI = $this->_updateOMNISubscriber(
                        $connection,
                        $group_details,
                        $is_service_set_changed,
                        $subscriber_details,
                        $old_subscriber_details
                    );

                    if (is_array($updateOMNI)
                        && array_key_exists('ERROR_CODE', $updateOMNI)) {
                        if ($this->_isErrorEnabled()) {
                            $this->_error('Unable to update OMNI client user.');
                        }
                        $this->_rollback_update_subscriber_details(
                            $connection,
                            $group_details,
                            $subscriber_details,
                            $call_executed_list,
                            $old_subscriber_details
                        );

                        return $updateOMNI;
                    }
                    $call_executed_list[] = 'UpdateOmniSubscriber';
                }

                //Update or create rich messaging on cim
                if (UtilityMethods::is_rich_messaging_service_bundle($service_set_value)) {
                    $servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR ."|" .ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                    $group_details->cim_group_identifier = $group_details->group_identifier;
                    if(UtilityMethods::is_rich_messaging_service_bundle ( $old_subscriber_details['service_set_value'] )){
                        $update_richmsg=$individualProv->modifyRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
                        if (UtilityMethods::isNotEqual ( $update_richmsg [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
                            if ($this->_isErrorEnabled ()) {
                                $this->_error ( "Unable to modify subscriber on CIM." );
                            }
                            $this->_check_translated_response ( $update_richmsg, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED );
                        }
                        $call_executed_list[] = "updateCIMSubscriber";
                    } else {
                        $create_richmsg = $individualProv->createRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
                        if (preg_match('/Invalid group/i', $create_richmsg[ProvisioningConstant::A2_RESPONSE])) {
                            $response = $this->createMissingCIMGroupAndMember($connection, $group_details, $subscriber_details, $servers);
                            if (array_key_exists('ERROR_CODE', $response)) {
                                $this->_check_translated_response($response['ERROR_MESSAGE'], $response['ERROR_CODE']);
                            }
                        } elseif (UtilityMethods::isNotEqual ( $create_richmsg [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG )) {
                            $this->_error('Unable to create subscriber on CIM.');
                            $this->_check_translated_response ( $create_richmsg, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED );
                        }
                        $call_executed_list[] = "createRichMessagingAccount";
                    }
                }

                //Delete rich messaging on cim
                if (
                    UtilityMethods::is_rich_messaging_service_bundle($old_subscriber_details['service_set_value'])
                    && !UtilityMethods::is_rich_messaging_service_bundle($subscriber_details['service_set_value'])
                    && (
                        !UtilityMethods::is_kbs_api_consumer_service_bundle($subscriber_details['service_set_value'])
                        || (
                            UtilityMethods::is_kbs_api_consumer_service_bundle($subscriber_details['service_set_value'])
                            && !UtilityMethods::is_VoIP_number_not_empty($subscriber_details['voip_numbers'])
                        )
                    )
                ) {

                    $deleteRichmsg = $individualProv->deleterRichMessagingAccount(
                        $connection,
                        $group_details,
                        $subscriber_details
                    );
                    if (
                        UtilityMethods::isNotEqual(
                            $deleteRichmsg[ProvisioningConstant::A2_RESPONSE],
                            CommonConstant::PROVISIONING_SUCCESS_MSG
                        )
                    ) {
                        if ($this->_isErrorEnabled()) {
                            $this->_error('Unable to delete subscriber on CIM.');
                        }
                        $this->_check_translated_response(
                            $update_richmsg,
                            ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED
                        );
                    }
                    $call_executed_list[] = 'deleteRichMessagingAccount';
                }

                $psxFacade = new PSXFacade();
                if (!empty($voip_numbers_diff ['REMOVED_ITEMS'])) {
                    // Delete voip numbers from PSX
                    $psxFacade->deleteFromPSX($voip_numbers_diff['REMOVED_ITEMS'], $group_details->group_id);
                }
                if (
                    !empty($voip_numbers_diff['ADDED_ITEMS'])
                    && !UtilityMethods::is_standalone_voicemail_menu_bundle($menu)
                ) {
                    // Provision voip numbers to PSX
                    $psxFacade->addToPsx(
                        $voip_numbers_diff['ADDED_ITEMS'],
                        $site_service_information['sesm_name'],
                        $group_details->group_id,
                        $connection
                    );
                }

				// Update Mida User

				if (strcmp($group_details->contact_center_type, ProvisioningConstant::menu_name_mida) == 0 && !array_key_exists ('ERROR_CODE', $response)){
					if(($subscriber_details['service_access_status'] != 'INACTIVE') && (UtilityMethods::is_mida_bundle ( $subscriber_details ["service_set_value"] ))){
                        $oldVoipDiff = array_diff($old_subscriber_details['voip_numbers'], $subscriber_details['voip_numbers']);
                        $newVoipDiff = array_diff($subscriber_details['voip_numbers'], $old_subscriber_details['voip_numbers']);
                        $voipNumberChange = false;
                        if (UtilityMethods::isNotEmpty($oldVoipDiff)
                            || UtilityMethods::isNotEmpty($newVoipDiff)
                            || (
                                isset($old_subscriber_details['voip_numbers'][0])
                                && isset($subscriber_details['voip_numbers'][0])
                                && $old_subscriber_details['voip_numbers'][0] != $subscriber_details['voip_numbers'][0]
                            )
                        ){
                            $voipNumberChange = true;
                        }
						$mida = new MidaFacade();
						$response = $mida->update_mida_user($connection, $subscriber_details, $group_details->business_name, $voipNumberChange);
						if(!empty($response['message']) && $response['message'] != ProvisioningConstant::PROVISIONING_SUCCESS_MSG){
							$this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details );
							$response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
								$this->_error ( 'Unable to update mida user with subscriber id ' . $subscriber_details["user_id"] . ". " . $response['ERROR_MESSAGE']);
							return $response_array;
						}
					}
                    // Delete Mida User
                    if (UtilityMethods::is_mida_bundle ( $old_subscriber_details['service_set_value'] ) && !UtilityMethods::is_mida_bundle ( $subscriber_details['service_set_value'])){
                        $subscriber_details['mida_user_id'] = MidaUserDao::get_mida_user_id_by_user_id($connection,$subscriber_details ['user_id']);
                        if(!empty($subscriber_details['mida_user_id'])){
                            $prov_system_id = $subscriber_details ["prov_system_id"];
                            $extension_id = MidaUserDao::get_extension_id_by_user_id($connection, $subscriber_details ['user_id']);
                            $mida_facade = new MidaFacade;
                            $mida_facade->delete_mida_user($connection, $subscriber_details, $prov_system_id, $extension_id);
                        }
                    }
                }

                if (UtilityMethods::isIntercomServiceBundle($service_set_value) && !UtilityMethods::isIntercomServiceBundle($old_service_set_value)) {
                    $this->setIPLForIntercom($connection, $group_details->top_level_domain, $subscriber_details);
                }

				$pstn_array = $subscriber_details['voip_numbers'];
                $pstn_array = array_merge($pstn_array, $old_subscriber_details['voip_numbers']);
                $pstn_did_vacant_userid_array = [];
                if(count($pstn_array) != 0) {
                    $pstn_did_vacant_userid_array = PstndidDao::get_unique_vacant_user_id_for_pstndid_numbers($connection, $pstn_array);
                }

				if(count($pstn_did_vacant_userid_array) != 0) {
                    if (VACANT_NUMBER_NEW_A2_SERVICE) {
                        $this->updateDIDFromVacantList(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $subscriber_details ["voip_numbers"],
                            $old_subscriber_details["voip_numbers"]
                        );
                    } else {
                        $this->updateVacentPstndidNumbers(
                            $connection,
                            ProvUtility::getPstnDidDomain($connection, $group_details),
                            ProvUtility::getPstnDidGroupId($group_details),
                            $pstn_did_vacant_userid_array
                        );
                    }
                }
                DbConnector::commitTransaction ( $connection );
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Update Successful for Configured Details for Subscriber:" . $user_id );
				}
			} // end of try block
			catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Updating Details for Configured Subscriber Failed!", $e );
				}
				//
				/*
				 * On Failure to update subscriber, perform the following rollbacks
				 * 1. Rollback user updated in A2 before vacant update, so PSTN can be re-assigned to vacant users.
				 * 2. Cancel PSTN Did that was marked as in progress and update vacant pstn did in A2
				 */
				$this->_rollback_update_subscriber_details ( $connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details );

				if (in_array ( 'moveSingleUser', $call_executed_list )) {
					// re-add subscriber to cal answer group for old site
					$call_routing_facade->re_add_subscriber_call_routing_group ( $connection, $subscriber_details ["user_id"], $call_routing_group_list, $group_details, true );
				}
                // This function has been moved to rollback_update_subscriber_details
				//$this->_reset_prov_in_progress_data_for_update ( $connection, $group_details, $subscriber_details, $old_subscriber_details );
				if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
					return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
				}
				return SubscriberValidator::build_error_message ( ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED, null );
			}
		}  // end of if(count($update_param)>0)
		else {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " No changes found to Update Configured Details for Subscriber:" . $user_id );
			}
		} // end of else-if(count($update_param)>0)
		return true;
	}

	// end of method _update_non_provision_subscriber_details()
	private function _update_kandy_subscriber($connection, $group_details, $is_service_set_changed, $service_set_value, $old_service_set_value, $subscriber_details, $old_subscriber_details) {
		$call_executed_list = array();
		$response_array = array();
		if ($is_service_set_changed) {
			if (UtilityMethods::is_kandy_msisdn_bundle ( $service_set_value ) && ! UtilityMethods::is_kandy_msisdn_bundle ( $old_service_set_value )) {
				// If user subscribed to KANDY need to create KANDY user from scratch.
				if (! $this->_provision_kandy_subscriber ( $connection, $group_details, $subscriber_details, $response_array)) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Failed SubscriberFacade->_update_kandy_subscriber. Unable to provision Kandy user." );
					}
					$this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
					$error_array ['ERROR_CODE'] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
					return $error_array;
				}
				$call_executed_list[] = 'addKandySubscriber';
			} else if (! UtilityMethods::is_kandy_msisdn_bundle ( $service_set_value ) && UtilityMethods::is_kandy_msisdn_bundle ( $old_service_set_value )) {
				// If user unsubscribed from KANDY need to remove KANDY user.
				if (! $this->_delete_kandy_subscriber ( $connection, $group_details, $subscriber_details )) {
					if ($this->_isErrorEnabled ()) {
						$this->_error ( "Failed SubscriberFacade->_update_kandy_subscriber. Unable to remove Kandy user." );
					}
					$this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
					$error_array ['ERROR_CODE'] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
					return $error_array;
				}
				$call_executed_list[] = 'deleteKandySubscriber';
			}
		}
		// If user already subscribed to KANDY remove and create the user from scratch only if sip password or mobile number has changed.
		// There is no modify function in KANDY.
		if (UtilityMethods::is_kandy_msisdn_bundle ( $service_set_value ) && (UtilityMethods::isNotEqual ( $subscriber_details ["mobile_number"], $old_subscriber_details ["mobile_number"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["first_name"], $old_subscriber_details ["first_name"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["last_name"], $old_subscriber_details ["last_name"] ))) {
			$update_kandy_response = $this->update_kandy_subscriber ( $connection, $group_details, $subscriber_details );
			if (! $update_kandy_response) {
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Failed SubscriberFacade->update_kandy_subscriber. Unable to update Kandy user." );
				}
				$this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
				$error_array ['ERROR_CODE'] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
				return $error_array;
			}
			$call_executed_list[] = 'updateKandySubscriber';
		}

		if (UtilityMethods::is_kandy_msisdn_bundle ( $service_set_value ) && (UtilityMethods::isNotEqual ( $subscriber_details ["email"], $old_subscriber_details ["email"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["user_password"], $old_subscriber_details ["user_password"] ) || UtilityMethods::isNotEqual ( $subscriber_details ["voice_mail_directory_number"], $old_subscriber_details ["voice_mail_directory_number"] ) || (UtilityMethods::is_nonstandalone_voicemail_menu_bundle ( $subscriber_details ["menu"] ) && UtilityMethods::isNotEqual ( $subscriber_details ["voicemail_pin"], $old_subscriber_details ["voicemail_pin"] )))) {
			$modify_kandy_response = $this->modify_kandy_subscriber ( $connection, $group_details, $subscriber_details );
			if (! $modify_kandy_response) {
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Failed SubscriberFacade->modify_kandy_subscriber. Unable to update Kandy user." );
				}
				$this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
				$error_array ['ERROR_CODE'] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
				return $error_array;
			}
			$call_executed_list[] = 'modifyKandySubscriber';

		}
		return $response_array;
	}

    /**
     * Internal Method to update OMNI subscriber
     *
     * @param object $connection
     * @param object $groupDetails
     * @param bool $isServiceSetChanged
     * @param array $subscriberDetails
     * @param array $oldSubscriberDetails
     *
     * @return array
     */
    private function _updateOMNISubscriber(
        $connection,
        $groupDetails,
        $isServiceSetChanged,
        $subscriberDetails,
        $oldSubscriberDetails
    )
    {
        $callExecutedList = [];

        $serviceSetValue = $subscriberDetails['service_set_value'];
        $oldServiceSetValue = $oldSubscriberDetails['service_set_value'];

        if ($isServiceSetChanged) {
            if (UtilityMethods::is_omniclient_service_bundle($serviceSetValue)
                && !UtilityMethods::is_omniclient_service_bundle($oldServiceSetValue)) {

                if (!UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)
                    && UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($oldServiceSetValue)) {

                    $isOldSpidrSubscriberExists = $this->getSpidrSubscriber(
                        $connection,
                        $groupDetails,
                        $oldSubscriberDetails
                    );

                    if ($isOldSpidrSubscriberExists) {
                        if ($this->_isDebugEnabled()) {
                            $this->_debug('Previously added SPiDR subscriber found.');
                        }

                        $spidrResponse = $this->deleteSpidrSubscriber(
                            $connection,
                            $groupDetails,
                            $oldSubscriberDetails,
                            Spider::TYPE_ANON_CALLME
                        );

                        if (!$spidrResponse) {
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails);

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'deleteSpidrSubscriber';
                    }
                }

                $spidrSubscriber = $this->getSpidrSubscriber($connection, $groupDetails, $subscriberDetails);
                // if subscriber does not exist on SPIDR yet, create
                if (!$spidrSubscriber) {
                    $spidrResponse = $this->createSpidrSubscriber(
                        $connection,
                        $groupDetails,
                        $subscriberDetails,
                        $callExecutedList,
                        Spider::TYPE_NUVIA
                    );

                    if (!$spidrResponse) {
                        $this->_rollback_update_subscriber_details(
                            $connection,
                            $groupDetails,
                            $subscriberDetails,
                            $callExecutedList,
                            $oldSubscriberDetails
                        );

                        return [
                            'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_CREATE_SUBSCRIBER_ON_SPIDR
                        ];
                    }
                    $callExecutedList[] = 'addSpidrSubscriber';
                    // if subscriber was already created on SPIDR update with appropriate service set
                } else {
                    $userID = UtilityMethods::get_subscriber_id($subscriberDetails['user_id']);
                    $spidrAccountID = $userID . '-' . $subscriberDetails['top_level_domain'];
                    $extProviderID = $userID . '@' . $subscriberDetails['top_level_domain'];

                    $spidrReqParams = [
                        'userID' => $extProviderID,
                        'userName' => $spidrAccountID,
                        'spider_name' => Spider::TYPE_NUVIA,
                        'firstName' => $subscriberDetails['first_name'],
                        'lastName' => $subscriberDetails['last_name'],
                        'password' => $subscriberDetails['user_password'],
                        'provSystem' => $subscriberDetails['prov_system_id'],
                        'spiderProducts' => ProvisioningConstant::SPIDR_PRODUCTS
                    ];

                    $spidrProv = new Spider();
                    $spidrResponse = $spidrProv->modifySubscriber($connection, $spidrReqParams);
                    if (UtilityMethods::isNotEqual(
                        $spidrResponse[ProvisioningConstant::A2_RESPONSE],
                        ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
                    ) {
                        if ($this->_isErrorEnabled()) {
                            $this->_error('update_kandy_subscriber unable to update SPiDR user '
                                . $subscriberDetails['user_id'] . ' response is '
                                . $spidrResponse[ProvisioningConstant::A2_RESPONSE]
                            );
                        }
                    }
                }
            } elseif (!UtilityMethods::is_omniclient_service_bundle($serviceSetValue)
                && UtilityMethods::is_omniclient_service_bundle($oldServiceSetValue)) {
                if (!UtilityMethods::is_livesupport_service_bundle($serviceSetValue)
                    && !$this->_isApiConsumerOrApiCallMeServiceBundle($serviceSetValue)) {

                    $spidrSubscriber = $this->getSpidrSubscriber($connection, $groupDetails, $subscriberDetails);
                    if ($spidrSubscriber) {
                        $spidrResponse = $this->deleteSpidrSubscriber(
                            $connection,
                            $groupDetails,
                            $subscriberDetails,
                            Spider::TYPE_NUVIA
                        );

                        if (!$spidrResponse) {
                            $this->_rollback_update_subscriber_details(
                                $connection, $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails
                            );

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'deleteSpidrSubscriber';
                    }
                }
            }
        }

        $oldFirstName = $oldSubscriberDetails['first_name'];
        $oldLastName = $oldSubscriberDetails['last_name'];
        $oldUserPassword = $oldSubscriberDetails['user_password'];

        if (UtilityMethods::is_omniclient_service_bundle($serviceSetValue)
            && (UtilityMethods::isNotEqual($subscriberDetails['first_name'], $oldFirstName)
                || UtilityMethods::isNotEqual($subscriberDetails['last_name'], $oldLastName)
                || UtilityMethods::isNotEqual($subscriberDetails['user_password'], $oldUserPassword)
                || UtilityMethods::isNotEqual($subscriberDetails['service_set_value'], $oldServiceSetValue))) {

            if (UtilityMethods::isNull($subscriberDetails['user_password'])) {
                $subscriberDetails['user_password'] = $oldUserPassword;
            }

            $updateResponse = $this->update_omni_subscriber($connection, $groupDetails, $subscriberDetails);
            if (!$updateResponse) {
                $this->_rollback_update_subscriber_details(
                    $connection,
                    $groupDetails,
                    $subscriberDetails,
                    $callExecutedList,
                    $oldSubscriberDetails
                );

                return [
                    'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                ];
            }
            $callExecutedList[] = 'updateSpidrSubscriber';
        }

        return [];
    }

    /**
     * Method to update API CONSUMER or API CALLME Subscriber
     *
     * @param PDO $connection
     * @param object $groupDetails
     * @param bool $isServiceSetChanged
     * @param array $subscriberDetails
     * @param array $oldSubscriberDetails
     *
     * @return array
     * @throws Exception
     */
    private function _updateApiConsumerSubscriber(
        $connection,
        $groupDetails,
        $isServiceSetChanged,
        $subscriberDetails,
        $oldSubscriberDetails)
    {
        $this->_debug('# _updateApiConsumerSubscriber');

        $callExecutedList = [];

        $createSMSAccountRequired = false;
        $deleteSMSAccountRequired = false;
        $subscriberDetailsSMS = $subscriberDetails;

        $spidrProv = new Spider(Spider::TYPE_ANON_CALLME);
        $individualProv = new Individual();

        $extProvTypeNuvia = Spider::TYPE_NUVIA;
        $extProvTypeCallMe = Spider::TYPE_ANON_CALLME;

        $DEVICE_TYPE_A2 = ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
        $DEVICE_TYPE_SPIDR = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR;
        $servers = $DEVICE_TYPE_SPIDR . '|' . $DEVICE_TYPE_A2;

        $nuviaProvider = ExternalProviderConstant::EXTERNAL_PROVIDERS['NUVIA_PROVIDER'];
        $callmeProvider = ExternalProviderConstant::EXTERNAL_PROVIDERS['CALLME_PROVIDER'];
        $kbsApiCallMeProvider = ExternalProviderConstant::EXTERNAL_PROVIDERS['KBS_API_CALLME_PROVIDER'];

        $extProviderList = $this->getListOfExternalProviders($connection, $groupDetails->group_id);

        $fullUserID = $subscriberDetails['user_id'];
        $provSystemID = $subscriberDetails['prov_system_id'];

        $serviceSetValue = $subscriberDetails['service_set_value'];
        $oldServiceSetValue = $oldSubscriberDetails['service_set_value'];

        $externalProvider = $extProviderList[$nuviaProvider];

        if (UtilityMethods::is_api_callme_service_bundle($serviceSetValue)) {
            $externalProvider = $extProviderList[$callmeProvider];
        }

        $userID = UtilityMethods::get_subscriber_id($fullUserID);
        $spidrAccountID = $userID . '-' . $groupDetails->top_level_domain;
        $extProviderID = $userID . '@' . $groupDetails->top_level_domain;

        $oldDestinationDigits = '';
        if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($oldServiceSetValue)) {
            $oldDestinationDigits = $oldSubscriberDetails['service_set_value'];
        }

        $destinationDigits = '';
        if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
            $destinationDigits = $subscriberDetails['destination'];
            $spidrAccountID = $destinationDigits . '-' . $groupDetails->top_level_domain;
            $extProviderID = $destinationDigits . '@' . $groupDetails->top_level_domain;
            if (UtilityMethods::isNotEmpty($extProviderList[$kbsApiCallMeProvider])) {
                $externalProvider = $extProviderList[$kbsApiCallMeProvider];
            }
        }

        /*
         * Check if service set has changed
         * If it has that provisioning on some external modules will need to change
         * accordingly to the changes
         */
        if ($isServiceSetChanged) {
            if ($this->_isDebugEnabled()) {
                $this->_debug('API Consumer Product Service Set Changed');
            }
            /*
             * if the new service set is API Consumer and it was not API Consumer before
             * than we will need to create cim account
             * as well as create SPiDR account
             */
            if ($this->_isApiConsumerOrApiCallMeServiceBundle($serviceSetValue)
                && !$this->_isApiConsumerOrApiCallMeServiceBundle($oldServiceSetValue)) {

                // Check the service set is KBS_APICALLME or KBS_APICALLME_PSTN
                if (!UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
                    // Check the KBS_APICONSUMER service set is available
                    if (!UtilityMethods::is_kbs_api_consumer_service_bundle($serviceSetValue)
                        || (UtilityMethods::is_kbs_api_consumer_service_bundle($serviceSetValue)
                            && UtilityMethods::is_VoIP_number_not_empty($subscriberDetails['voip_numbers']))) {

                        $subscriberDetailsSMS = $subscriberDetails;
                        $userIDPosition = strpos($fullUserID, '@');
                        $subscriberDetailsSMS['voicemail_account'] = substr($fullUserID, 0, $userIDPosition);

                        if (UtilityMethods::is_rich_messaging_service_bundle($oldServiceSetValue)) {
                            $deleteSMSAccountRequired = true;
                        }
                        $createSMSAccountRequired = true;
                    }
                }

                // ACL-15608 - KBS-API-003-004-005 Addition to the KBS Portal
                // The previous product was not KBS API CallMe or KBS API CallMe PSTN.
                // Please get the previously created subscriber and delete it.
                // Because the user id will be replaced with the destination digit
                // when there is kbs_api_callme or kbs_api_callme_pstn service set on the product.
                // That's why we have to delete old subscriber
                // and then add a new subscriber which has destination digit as userID
                if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {

                    // If the servis set is KBS_APICALLME or KBS_APICALLME_PSTN, then should check if there is an external provider
                    if (UtilityMethods::isEmpty($extProviderList[$kbsApiCallMeProvider])) {
                        if ($this->_isErrorEnabled()) {
                            $this->_error('There is no external provider.');
                        }
                        $this->_check_translated_response(
                            [],
                            ApiResponseConstant::UPDATE_SUBSCRIBER_CREATE_SUBSCRIBER_WITH_NO_EXTERNAL_PROVIDER_ON_SPIDR,
                            ''
                        );
                    }

                    $isOldSpidrSubscriberExists = $this->getSpidrSubscriber(
                        $connection,
                        $groupDetails,
                        $oldSubscriberDetails
                    );

                    if ($isOldSpidrSubscriberExists) {
                        if ($this->_isDebugEnabled()) {
                            $this->_debug('Previously added SPiDR subscriber found.');
                        }

                        $spidrResponse = $this->deleteSpidrSubscriber(
                            $connection,
                            $groupDetails,
                            $oldSubscriberDetails,
                            $extProvTypeNuvia
                        );

                        if (!$spidrResponse) {
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails);

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'deleteSpidrSubscriber';
                    }
                }

                // Need to get SPiDR in case it was created by another component
                $isSpidrSubscriberExists = $this->getSpidrSubscriber($connection, $groupDetails, $subscriberDetails);

                if (!$isSpidrSubscriberExists) {
                    if ($this->_isDebugEnabled()) {
                        $this->_debug('SPiDR subscriber not found. Trying to create new subscriber');
                    }

                    $isSpidrSubscriberCreated = $this->createSpidrSubscriber(
                        $connection,
                        $groupDetails,
                        $subscriberDetails,
                        $callExecutedList,
                        $extProvTypeCallMe
                    );

                    if (!$isSpidrSubscriberCreated) {
                        $this->_rollback_update_subscriber_details(
                            $connection,
                            $groupDetails,
                            $subscriberDetails,
                            $callExecutedList,
                            $oldSubscriberDetails
                        );

                        return [
                            'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                        ];
                    }
                    $callExecutedList[] = 'addSpidrSubscriber';

                    // If subscriber was created by another component
                    // update it with services required for API consumer
                } else {

                    $spidrProv->removeSpidrProduct(
                        $connection,
                        $spidrAccountID,
                        $provSystemID,
                        ProvisioningConstant::INSTANT_MESSAGE
                    );

                    if (UtilityMethods::is_api_consumer_service_bundle($serviceSetValue)) {

                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_NO_CALLME;
                        $spidrProv->removeSpidrProduct(
                            $connection,
                            $spidrAccountID,
                            $provSystemID,
                            ProvisioningConstant::CALL_ME
                        );

                    } elseif (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_KBS_API_CALLME;
                    } else {
                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_CALLME;
                    }

                    $spidrReqParams = [
                        'userID' => $extProviderID,
                        'userName' => $spidrAccountID,
                        'firstName' => $subscriberDetails['first_name'],
                        'lastName' => $subscriberDetails['last_name'],
                        'password' => $subscriberDetails['user_password'],
                        'provSystem' => $provSystemID,
                        'spider_name' => $externalProvider,
                        'spiderProducts' => $spidrProducts
                    ];

                    $spidrResponse = $spidrProv->modifySubscriber($connection, $spidrReqParams);

                    if (UtilityMethods::isNotEqual(
                        $spidrResponse[ProvisioningConstant::A2_RESPONSE],
                        ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
                    ) {

                        $this->_rollback_update_subscriber_details(
                            $connection,
                            $groupDetails,
                            $subscriberDetails,
                            $callExecutedList,
                            $oldSubscriberDetails);

                        return [
                            'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                        ];
                    }

                    if (UtilityMethods::is_api_callme_service_bundle($serviceSetValue)) {

                        $publicChargeID = 'unknown@' . $groupDetails->top_level_domain;

                        $tokenized = '';
                        $tokenRealm = '';
                        if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
                            $publicChargeID = $fullUserID;
                            $tokenized = UtilityMethods::isForceTokenized($subscriberDetails['force_tokenized_identity']);
                            $tokenRealm = $this->getCallMeAuthSchemaName(
                                $connection,
                                $subscriberDetails['call_me_auth_token_id']
                            );

                            $this->updateKBSAPICallMeAndCallMePSTNRestfulClientService(
                                $connection,
                                $spidrProv,
                                $serviceSetValue,
                                $spidrAccountID,
                                $provSystemID
                            );
                        }

                        $spidrProv->updateCallMeService(
                            $connection,
                            $spidrAccountID,
                            $provSystemID,
                            $publicChargeID,
                            $tokenized,
                            $tokenRealm
                        );
                    }
                    $callExecutedList[] = 'modifySpiderSubscriber';
                }

                /*
                 * if we are changing from API Consumer to API Call me or wise versa
                 * we need to update SPIDR account
                 */
            } elseif ($this->_isApiConsumerOrApiCallMeServiceBundle($serviceSetValue)
                && $this->_isApiConsumerOrApiCallMeServiceBundle($oldServiceSetValue)) {

                $spidrSubscriber = $this->getSpidrSubscriber($connection, $groupDetails, $subscriberDetails);


                if ($spidrSubscriber) {

                    $spidrProv->removeSpidrProduct(
                        $connection,
                        $spidrAccountID,
                        $provSystemID,
                        ProvisioningConstant::INSTANT_MESSAGE
                    );

                    if (UtilityMethods::is_api_consumer_service_bundle($serviceSetValue)) {
                        $spidrProv->removeSpidrProduct(
                            $connection,
                            $spidrAccountID,
                            $provSystemID,
                            ProvisioningConstant::CALL_ME
                        );

                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_NO_CALLME;
                    } elseif (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_KBS_API_CALLME;
                    } else {
                        $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_CALLME;
                    }

                    $spidrReqParams = [
                        'userID' => $extProviderID,
                        'userName' => $spidrAccountID,
                        'firstName' => $subscriberDetails['first_name'],
                        'lastName' => $subscriberDetails['last_name'],
                        'password' => $subscriberDetails['user_password'],
                        'provSystem' => $provSystemID,
                        'spider_name' => $externalProvider,
                        'spiderProducts' => $spidrProducts
                    ];

                    $spidrResponse = $spidrProv->modifySubscriber($connection, $spidrReqParams);

                    if (UtilityMethods::isNotEqual(
                        $spidrResponse[ProvisioningConstant::A2_RESPONSE],
                        ProvisioningConstant::PROVISIONING_SUCCESS_MSG)) {

                        $this->_rollback_update_subscriber_details(
                            $connection,
                            $groupDetails,
                            $subscriberDetails,
                            $callExecutedList,
                            $oldSubscriberDetails);

                        return [
                            'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                        ];
                    }

                    if (!UtilityMethods::is_api_consumer_service_bundle($serviceSetValue)) {

                        $publicChargeID = 'unknown@' . $groupDetails->top_level_domain;

                        $tokenized = '';
                        $tokenRealm = '';
                        if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
                            $publicChargeID = $fullUserID;
                            $tokenized = UtilityMethods::isForceTokenized(
                                $subscriberDetails['force_tokenized_identity']
                            );
                            $tokenRealm = $this->getCallMeAuthSchemaName(
                                $connection,
                                $subscriberDetails['call_me_auth_token_id']
                            );

                            $this->updateKBSAPICallMeAndCallMePSTNRestfulClientService(
                                $connection,
                                $spidrProv,
                                $serviceSetValue,
                                $spidrAccountID,
                                $provSystemID
                            );
                        }

                        $spidrProv->updateCallMeService(
                            $connection,
                            $spidrAccountID,
                            $provSystemID,
                            $publicChargeID,
                            $tokenized,
                            $tokenRealm
                        );
                    }

                }
                $callExecutedList[] = 'modifySpiderSubscriber';

                if ((UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)
                        && UtilityMethods::is_api_consumer_service_bundle($oldServiceSetValue))
                    || (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($oldServiceSetValue)
                        && UtilityMethods::is_api_consumer_service_bundle($serviceSetValue))) {
                    $spidrSubscriber = $this->getSpidrSubscriber($connection, $groupDetails, $oldSubscriberDetails);

                    if ($spidrSubscriber) {
                        $this->_debug('Previously added SPiDR subscriber found.');
                        $spidrResponse = $this->deleteSpidrSubscriber(
                            $connection,
                            $groupDetails,
                            $oldSubscriberDetails,
                            $extProvTypeNuvia
                        );

                        if (!$spidrResponse) {
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails);

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'deleteSpidrSubscriber';
                    }

                    $isSpidrSubscriberExists = $this->getSpidrSubscriber($connection, $groupDetails, $subscriberDetails);

                    if (!$isSpidrSubscriberExists) {
                        $this->_debug('SPiDR subscriber not found. Trying to create new subscriber');
                        $isSpidrSubscriberCreated = $this->createSpidrSubscriber(
                            $connection,
                            $groupDetails,
                            $subscriberDetails,
                            $callExecutedList,
                            $extProvTypeCallMe
                        );

                        if (!$isSpidrSubscriberCreated) {
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails
                            );

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'addSpidrSubscriber';

                    }
                }

                /*
                 * if we are removing API Consumer or API CallMe from Subscriber
                 * delete CIM account
                 * and delete or update SPiDR
                 */
            } elseif ($this->_isApiConsumerOrApiCallMeServiceBundle($oldServiceSetValue)
                && !$this->_isApiConsumerOrApiCallMeServiceBundle($serviceSetValue)) {

                if (UtilityMethods::is_VoIP_number_not_empty($subscriberDetails['voip_numbers'])) {
                    $PSTNDid = $subscriberDetails['voip_numbers'];
                } else {
                    $PSTNDid = PstndidDao::get_primary_pstn_did($connection, $subscriberDetails['user_id']);
                }

                // Check the KBS_APICALLME or KBS_APICALLME_PSTN service sets
                if (!UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($oldServiceSetValue)) {

                    // Check the KBS_APICONSUMER service set is available
                    if (!UtilityMethods::is_kbs_api_consumer_service_bundle($oldServiceSetValue)
                        || (UtilityMethods::is_kbs_api_consumer_service_bundle($oldServiceSetValue)
                            && UtilityMethods::isNotEmpty($PSTNDid))) {

                        $subscriberDetailsSMS = $subscriberDetails;
                        $userIDPosition = strpos($fullUserID, '@');
                        $subscriberDetailsSMS['voicemail_account'] = substr($fullUserID, 0, $userIDPosition);

                        $deleteSMSAccountRequired = true;
                    }
                }

                if (!UtilityMethods::is_omniclient_service_bundle($serviceSetValue)
                    && !UtilityMethods::is_livesupport_service_bundle($serviceSetValue)
                    && !UtilityMethods::is_callrecording_service_bundle($serviceSetValue)) {

                    if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($oldServiceSetValue)) {
                        $spidrSubscriber = $this->getSpidrSubscriber($connection, $groupDetails, $oldSubscriberDetails);
                    } else {
                        $spidrSubscriber = $this->getSpidrSubscriber($connection, $groupDetails, $subscriberDetails);
                    }

                    if ($spidrSubscriber) {
                        if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($oldServiceSetValue)) {
                            $spidrResponse = $this->deleteSpidrSubscriber(
                                $connection,
                                $groupDetails,
                                $oldSubscriberDetails,
                                $extProvTypeCallMe
                            );
                        } else {
                            $spidrResponse = $this->deleteSpidrSubscriber(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $extProvTypeNuvia
                            );
                        }

                        if (!$spidrResponse) {
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails);

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'deleteSpidrSubscriber';


                        $isSpidrSubscriberCreated = $this->createSpidrSubscriber(
                            $connection,
                            $groupDetails,
                            $subscriberDetails,
                            $callExecutedList,
                            $extProvTypeNuvia
                        );

                        if (!$isSpidrSubscriberCreated) {
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails
                            );

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'addSpidrSubscriber';
                    }
                }
            }
        }

        $oldFirstName = $oldSubscriberDetails['first_name'];
        $oldLastName = $oldSubscriberDetails['last_name'];
        $oldUserPassword = $oldSubscriberDetails['user_password'];
        $oldVoIPNumbers = $oldSubscriberDetails['voip_numbers'];
        $oldEmail = $oldSubscriberDetails['email'];

        // If any other values besides Service set changed on the subscriber,
        // update all the components subscriber exist on.
        if ((UtilityMethods::isNotEqual($subscriberDetails['first_name'], $oldFirstName)
                || UtilityMethods::isNotEqual($subscriberDetails['last_name'], $oldLastName)
                || UtilityMethods::isNotEqual($subscriberDetails['user_password'], $oldUserPassword)
                || UtilityMethods::isNotEqual($subscriberDetails['voip_numbers'], $oldVoIPNumbers)
                || UtilityMethods::isNotEqual($subscriberDetails['email'], $oldEmail)
                || (isset($destinationDigits) && !empty($destinationDigits)
                    && UtilityMethods::isNotEqual($destinationDigits, $oldDestinationDigits)))
            && $this->_isApiConsumerOrApiCallMeServiceBundle($serviceSetValue)) {

            if (UtilityMethods::isNull($subscriberDetails['user_password'])) {
                $subscriberDetails['user_password'] = $oldUserPassword;
            }

            $isVoIPNumberExist = UtilityMethods::is_VoIP_number_not_empty($subscriberDetails['voip_numbers']);
            $PSTNDid = PstndidDao::get_primary_pstn_did($connection, $subscriberDetails['user_id']);
            $isPSTNDidExist = UtilityMethods::isNotEmpty($PSTNDid);

            // Check the KBS_APICONSUMER service set is available
            if (!UtilityMethods::is_kbs_api_consumer_service_bundle($serviceSetValue)
                || (UtilityMethods::is_kbs_api_consumer_service_bundle($serviceSetValue)
                    && ($isVoIPNumberExist || $isPSTNDidExist))) {
                $subscriberDetailsSMS = $subscriberDetails;
                $userIDPosition = strpos($fullUserID, '@');
                $subscriberDetailsSMS['voicemail_account'] = substr($fullUserID, 0, $userIDPosition);

                if ($isVoIPNumberExist && !$isPSTNDidExist) {
                    // Check the KBS_APICALLME or KBS_APICALLME_PSTN service sets
                    if (!UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
                        $createSMSAccountRequired = true;
                    }

                } elseif (!$isVoIPNumberExist && $isPSTNDidExist) {
                    $deleteSMSAccountRequired = true;
                } else {

                    // Check the KBS_APICALLME or KBS_APICALLME_PSTN service sets
                    if (!UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
                        $CIMResponse = $individualProv->modifySMSAccount(
                            $connection,
                            $groupDetails,
                            $subscriberDetailsSMS, $servers);

                        if (UtilityMethods::isNotEqual(
                            $CIMResponse[ProvisioningConstant::A2_RESPONSE],
                            ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
                        ) {

                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails);

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'modifySMSAccount';
                    }
                }
            }

            $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_NO_CALLME;

            if (UtilityMethods::isKbsApiCallMeOrCallMePSTNServiceBundle($serviceSetValue)) {
                if (UtilityMethods::isNotNull($oldDestinationDigits)) {

                    $isSpidrSubscriberExists = $this->getSpidrSubscriber(
                        $connection,
                        $groupDetails,
                        $oldSubscriberDetails
                    );

                    if ($isSpidrSubscriberExists) {
                        $spidrResponse = $this->deleteSpidrSubscriber(
                            $connection,
                            $groupDetails,
                            $oldSubscriberDetails,
                            $extProvTypeCallMe
                        );

                        if (!$spidrResponse) {
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails);

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'deleteSpidrSubscriber';

                        $isSpidrSubscriberCreated = $this->createSpidrSubscriber(
                            $connection,
                            $groupDetails,
                            $subscriberDetails,
                            $callExecutedList,
                            $extProvTypeCallMe
                        );

                        if (!$isSpidrSubscriberCreated) {
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $groupDetails,
                                $subscriberDetails,
                                $callExecutedList,
                                $oldSubscriberDetails
                            );

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $callExecutedList[] = 'addSpidrSubscriber';
                    }
                }
                $spidrProducts = ProvisioningConstant::SPIDR_PRODUCTS_KBS_API_CALLME;
            } else {
                $spidrReqParams = [
                    'userID' => $extProviderID,
                    'userName' => $spidrAccountID,
                    'firstName' => $subscriberDetails['first_name'],
                    'lastName' => $subscriberDetails['last_name'],
                    'password' => $subscriberDetails['user_password'],
                    'provSystem' => $provSystemID,
                    'spider_name' => $externalProvider,
                    'spiderProducts' => $spidrProducts
                ];

                $spidrResponse = $spidrProv->modifySubscriber($connection, $spidrReqParams);

                if (UtilityMethods::isNotEqual(
                    $spidrResponse[ProvisioningConstant::A2_RESPONSE],
                    ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
                ) {

                    $this->_rollback_update_subscriber_details(
                        $connection,
                        $groupDetails,
                        $subscriberDetails,
                        $callExecutedList,
                        $oldSubscriberDetails);

                    return [
                        'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                    ];
                }
                $callExecutedList[] = 'modifySpiderSubscriber';
            }
        }

        if ($deleteSMSAccountRequired) {
            $CIMResponse = $individualProv->deleteSMSAccount(
                $connection,
                $groupDetails,
                $subscriberDetailsSMS);

            if (UtilityMethods::isNotEqual(
                $CIMResponse[ProvisioningConstant::A2_RESPONSE],
                ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
            ) {
                $this->_rollback_update_subscriber_details(
                    $connection,
                    $groupDetails,
                    $subscriberDetails,
                    $callExecutedList,
                    $oldSubscriberDetails);

                return [
                    'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                ];
            }

            $callExecutedList[] = 'deleteSMSAccount';
        }

        if ($createSMSAccountRequired) {
            $CIMResponse = $individualProv->createSMSAccount(
                $connection,
                $groupDetails,
                $subscriberDetailsSMS,
                $servers);

            if (UtilityMethods::isNotEqual(
                $CIMResponse[ProvisioningConstant::A2_RESPONSE],
                ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
            ) {

                $this->_rollback_update_subscriber_details(
                    $connection,
                    $groupDetails,
                    $subscriberDetails,
                    $callExecutedList,
                    $oldSubscriberDetails);

                return [
                    'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                ];
            }
        }

        $callExecutedList[] = 'createSMSAccount';
        return $callExecutedList;
    }

    private function _update_live_support_subscriber($connection, $group_details, $is_service_set_changed, $service_set_value, $old_service_set_value, $subscriber_details, $old_subscriber_details)
    {
        $agent_response = [];
        $livesupportfacade = new LiveSupportFacade();
        $ls_version = LiveSupportDao::ls_get_instance_details_by_group_id($connection, $group_details->group_id, "live_support_version");
        $response_array = [];
        $call_executed_list = [];
        $spiderProv = new models\external\prov\Spider ();

        if ($is_service_set_changed) {
            if (UtilityMethods::is_livesupport_service_bundle($service_set_value) && !UtilityMethods::is_livesupport_service_bundle($old_service_set_value)) {
                // If user subscribed to Live Support SKU need to create resources from scratch.
                if (UtilityMethods::isEqual($ls_version, ProvisioningConstant::LIVE_SUPPORT_KBS_VERSION)) {
                    //create CIM subscriber
                    $individualProv = new models\external\prov\Individual();
                    if (!UtilityMethods::isEqual($group_details->voice_mail_device_type, ProvisioningConstant::PROVISION_DEVICE_TYPE_IMM)) {
                        $servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR . "|" . ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                        $group_details->cim_group_identifier = $group_details->group_identifier;
                        $cim_response = $individualProv->modifyRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
                        $executeOptionCIM = 'updateCIMSubscriber';
                        if (UtilityMethods::isNotEqual($cim_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                            $this->_debug("The CIM account could not be modified. There is no such account. A new account will be created.");
                            $cim_response = $individualProv->createRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
                            $executeOptionCIM = 'createRichMessagingAccount';
                            if (UtilityMethods::isNotEqual($cim_response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                                if ($this->_isErrorEnabled()) {
                                    $this->_error("Unable to create or modify subscriber on CIM.");
                                }
                                $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                                $response_array["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                                return $response_array;
                            }
                        }
                        $call_executed_list[] = $executeOptionCIM;
                        //add CIM group
                        $group_details->member_group_identifier = "ls" . $group_details->group_identifier;
                        $add_group = $individualProv->addGroupMember($connection, $group_details, $subscriber_details);
                        if (UtilityMethods::isNotEqual($add_group [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error("Unable to aassign subscriber to live support group on CIM.");
                            }
                            $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                            $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                            return $response_array;
                        }
                        $call_executed_list[] = 'addGroupMember';
                    } else if (UtilityMethods::isEqual($group_details->voice_mail_device_type, ProvisioningConstant::PROVISION_DEVICE_TYPE_IMM)) {
                        $servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR . "|" . ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                        $group_details->cim_group_identifier = "ls" . $group_details->group_identifier;
                        $cim_response = $individualProv->createRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
                        if (UtilityMethods::isNotEqual($cim_response [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error("Unable to create subscriber on CIM.");
                            }
                            $this->_check_translated_response($cim_response, ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED);
                        }

                        $call_executed_list[] = "createRichMessagingAccount";
                    }
                    // Create SPiDR subscriber
                    $spidrSubscriber = $this->getSpidrSubscriber($connection, $group_details, $subscriber_details);

                    // If subscriber was not created on SPiDR before
                    if (!$spidrSubscriber) {
                        $spidrResponse = $this->createSpidrSubscriber(
                            $connection,
                            $group_details,
                            $subscriber_details,
                            $call_executed_list,
                            Spider::TYPE_NUVIA
                        );

                        if (!$spidrResponse) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error('Unable to create account on SPiDR.');
                            }
                            $this->_rollback_update_subscriber_details(
                                $connection,
                                $group_details,
                                $subscriber_details,
                                $call_executed_list,
                                $old_subscriber_details
                            );

                            return [
                                'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                            ];
                        }
                        $call_executed_list[] = 'addSpidrSubscriber';

                    } else {
                        //if subscriber was created before on SPIDR,
                        // update SPIDR with appropriate Products and external provider

                        $userId = UtilityMethods::get_subscriber_id($subscriber_details['user_id']);
                        $spidrAccountID = $userId . '' . $subscriber_details['top_level_domain'];

                        $spidrReqParams = [
                            'userID' => $subscriber_details['user_id'],
                            'userName' => $spidrAccountID,
                            'firstName' => $subscriber_details['first_name'],
                            'lastName' => $subscriber_details['last_name'],
                            'password' => UtilityMethods::sip_data_out($subscriber_details['password']),
                            'spider_name' => Spider::TYPE_NUVIA,
                            'provSystem' => $subscriber_details['prov_system_id'],
                            'spiderProducts' => ProvisioningConstant::SPIDR_PRODUCTS
                        ];

                        $spidrResponse = $spiderProv->modifySubscriber($connection, $spidrReqParams);
                        if (UtilityMethods::isNotEqual(
                            $spidrResponse[ProvisioningConstant::A2_RESPONSE],
                            ProvisioningConstant::PROVISIONING_SUCCESS_MSG)
                        ) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error('update_kandy_subscriber unable to update SPiDR user '
                                    . $subscriber_details['user_id'] . ' response is '
                                    . $spidrResponse[ProvisioningConstant::A2_RESPONSE]
                                );
                            }
                        }
                        $call_executed_list[] = 'modifySpiderSubscriber';
                    }
                }
                //Create Live Support Subscriber
                $agent_response = $livesupportfacade->create_agent($connection, $subscriber_details, $group_details);
                if (array_key_exists("ERROR_CODE", $agent_response)) {
                    if ($this->_isErrorEnabled()) {
                        $this->_error("Unable to create agent on Live Support.");
                    }
                    $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                    $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                    return $response_array;
                }
                $call_executed_list[] = 'addLiveSupportAgent';


            } else if (!UtilityMethods::is_livesupport_service_bundle($service_set_value) && UtilityMethods::is_livesupport_service_bundle($old_service_set_value)) {
                // If user unsubscribed from KANDY need to remove KANDY user.
                $ls_subscriber_details = $subscriber_details;
                $ls_subscriber_details['user_id'] = substr($subscriber_details['user_id'], 0, strpos($subscriber_details['user_id'], "@"));
                //Delete Live Support Agent
                $agent_response = $livesupportfacade->delete_agent($ls_subscriber_details, $group_details);
                if (array_key_exists("ERROR_CODE", $agent_response)) {
                    if ($this->_isErrorEnabled()) {
                        $this->_error("Unable to delete agent from Live Support.");
                    }
                    $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                    $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                    return $response_array;
                }
                $call_executed_list[] = 'deleteLiveSupportAgent';
                if (UtilityMethods::isEqual($ls_version, ProvisioningConstant::LIVE_SUPPORT_KBS_VERSION)) {
                    $individualProv = new models\external\prov\Individual();
                    if (!UtilityMethods::isEqual($group_details->voice_mail_device_type, ProvisioningConstant::PROVISION_DEVICE_TYPE_IMM)) {
                        $group_details->cim_group_identifier = $group_details->group_identifier;
                        $group_details->member_group_identifier = "ls" . $group_details->group_identifier;
                        //remove CIM group
                        $delete_group = $individualProv->removeGroupMember($connection, $group_details, $subscriber_details);
                        if (UtilityMethods::isNotEqual($delete_group [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error("Unable to delete CIM subscriber from group.");
                            }
                            $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                            $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                            return $response_array;
                        }
                        $call_executed_list[] = 'deleteGroupMember';
                        //remove rich messaging account
                        $delete_cim = $individualProv->deleterRichMessagingAccount($connection, $group_details, $subscriber_details);
                        if (UtilityMethods::isNotEqual($delete_cim [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error("Unable to delete subscriber from CIM.");
                            }
                            $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                            $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                            return $response_array;
                        }
                        $call_executed_list[] = 'deleteRichMessagingAccount';
                    } else if (UtilityMethods::isEqual($group_details->voice_mail_device_type, ProvisioningConstant::PROVISION_DEVICE_TYPE_IMM)) {
                        $group_details->cim_group_identifier = $group_details->group_identifier;
                        $delete_cim = $individualProv->deleterRichMessagingAccount($connection, $group_details, $subscriber_details);
                        if (UtilityMethods::isNotEqual($delete_cim [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                            if ($this->_isErrorEnabled()) {
                                $this->_error("Unable to delete subscriber from CIM.");
                            }
                            $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                            $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                            return $response_array;
                        }
                        $call_executed_list[] = 'deleteRichMessagingAccount';
                    }

                    //Delete SPiDR subscriber
                    if (!UtilityMethods::is_omniclient_service_bundle($service_set_value)
                        && !$this->_isApiConsumerOrApiCallMeServiceBundle($service_set_value)) {
                        $spidrSubscriber = $this->getSpidrSubscriber($connection, $group_details, $subscriber_details);
                        if ($spidrSubscriber) {
                            $spidrResponse = $this->deleteSpidrSubscriber(
                                $connection,
                                $group_details,
                                $subscriber_details,
                                Spider::TYPE_NUVIA
                            );

                            if (!$spidrResponse) {
                                if ($this->_isErrorEnabled()) {
                                    $this->_error('Unable to delete Live Support subscriber account on SPiDR.');
                                }
                                $this->_rollback_update_subscriber_details(
                                    $connection,
                                    $group_details,
                                    $subscriber_details,
                                    $call_executed_list,
                                    $old_subscriber_details
                                );

                                return [
                                    'ERROR_CODE' => ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED
                                ];
                            }
                        }
                        $call_executed_list[] = 'deleteSpidrSubscriber';
                    }
                }
            }
        }

        // If user already subscribed to Live Support
        if (
            UtilityMethods::is_livesupport_service_bundle($old_service_set_value)
            && (UtilityMethods::isNotEqual($subscriber_details['first_name'], $old_subscriber_details['first_name'])
                || UtilityMethods::isNotEqual($subscriber_details['last_name'], $old_subscriber_details['last_name'])
                || UtilityMethods::isNotEqual($subscriber_details['email'], $old_subscriber_details['email'])
                || UtilityMethods::isNotEqual($subscriber_details['user_password'], $old_subscriber_details['user_password'])
                || UtilityMethods::isNotEqual($subscriber_details['user_id'], $old_subscriber_details['user_id'])
                || UtilityMethods::isNotEqual($subscriber_details['service_set_value'], $old_subscriber_details['service_set_value'])
                || UtilityMethods::isNotEqual($subscriber_details['site_id'], $old_subscriber_details['site_id']))
        ) {
            //Update subscriber on live support
            $agent_response = $livesupportfacade->update_agent($subscriber_details, $group_details);
            if (array_key_exists("ERROR_CODE", $agent_response)) {
                if ($this->_isErrorEnabled()) {
                    $this->_error("Unable to update agent on Live Support.");
                }
                $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                return $response_array;
            }
            $call_executed_list[] = 'updateLiveSupportAgent';
            if (UtilityMethods::isEqual($ls_version, ProvisioningConstant::LIVE_SUPPORT_KBS_VERSION)) {
                //update account on SPiDR
                $update_resposne = $this->update_omni_subscriber($connection, $group_details, $subscriber_details);
                if (!$update_resposne) {
                    if ($this->_isErrorEnabled()) {
                        $this->_error("Unable to update SPiDR subscriber.");
                    }
                    $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                    $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                    return $response_array;
                }
                $call_executed_list[] = 'updateSpidrSubscriber';
                //Update account on CIM
                $individualProv = new models\external\prov\Individual();
                $servers = ProvisioningConstant::PROVISION_DEVICE_TYPE_SPIDR . "|" . ProvisioningConstant::PROVISION_DEVICE_TYPE_A2;
                $group_details->cim_group_identifier = $group_details->group_identifier;
                $update_cim = $individualProv->ModifyRichMessagingAccount($connection, $group_details, $subscriber_details, $servers);
                if (UtilityMethods::isNotEqual($update_cim [ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                    if ($this->_isErrorEnabled()) {
                        $this->_error("Unable to update CIM subscriber.");
                    }
                    $this->_rollback_update_subscriber_details($connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details);
                    $response_array ["ERROR_CODE"] = ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED;
                    return $response_array;
                }
                $call_executed_list[] = 'updateCIMSubscriber';
            }
        }
        return $agent_response;
    }

	private function _update_standalone_subscriber_details($connection, $subscriber_details, $group_details, $site_service_information, $old_subscriber_details) {
		$user_id = $subscriber_details ["user_id"];
		if ($this->_isDebugEnabled ()) {
			$this->_debug ( " Update Standalone Details for Subscriber:" . $user_id );
		}
		$service_set_value = $subscriber_details ["service_set_value"];
		$old_service_set_value = $old_subscriber_details ["service_set_value"];
		$menu = $subscriber_details ["menu"];
		$old_menu = $old_subscriber_details ["menu"];

		$update_param = array ();
		$product_diff_response_array = $this->_get_array_difference ( $old_subscriber_details ["product_ids"], $subscriber_details ["product_ids"], true );
		if ((count ( $product_diff_response_array ["REMOVED_ITEMS"] ) > 0) || (count ( $product_diff_response_array ["ADDED_ITEMS"] ) > 0)) {
			$update_param ["sku"] = $subscriber_details ["sku"];
			$update_param ["product_ids"] = $subscriber_details ["product_ids"];
		}

		if (UtilityMethods::isEmpty ( $old_service_set_value )) {
			$provision_response = SubscriberValidator::pre_process_provision_details ( $connection, $subscriber_details, $group_details, NULL );
		} else {
			$provision_response = SubscriberValidator::pre_process_provision_details ( $connection, $subscriber_details, $group_details, $old_subscriber_details );
		}
		if (is_array ( $provision_response )) {
			return $provision_response;
		}


        if (UtilityMethods::isMsTeamsMenuBundle($old_menu)) {
            $response = $this->updateMsTeamsMenuBundle($connection, $old_subscriber_details, $subscriber_details, $group_details);
            if (is_array($response)) {
                return $response;
            }
        } else {
            if (UtilityMethods::isEmpty($old_service_set_value) || !UtilityMethods::is_standalone_voicemail_menu_bundle($old_menu)) {
                $voicemail_response = SubscriberValidator::pre_process_voicemail_details($connection, $subscriber_details, $group_details, null);
            } else {
                $voicemail_response = SubscriberValidator::pre_process_voicemail_details($connection, $subscriber_details, $group_details, $old_subscriber_details);
            }
            if (is_array($voicemail_response)) {
                return $voicemail_response;
            }
        }

		$identityFields = [
				'site_id',
				'first_name',
				'last_name',
				'password',
				'role',
				'service_set_value',
                'default_status',
                'department'
        ];

		$settings_fields = array (
				"voice_mail_directory_number",
				"emails",
				"voicemail_pin",
				"voicemail_notification"
		);
		$advanced_settings_fields = array (
				"timezone",
				"timezone_id",
				"voicemail_service",
				"voicemail_server",
				"voicemail_number",
				"voicemail_device_id",
                "language",
                "is_eup_advanced_enabled"
		);
		$standalone_fields = array_merge($identityFields, $settings_fields, $advanced_settings_fields);

		$this->_update_array_for_changes ( $subscriber_details, $old_subscriber_details, $standalone_fields, $update_param );
		if (UtilityMethods::isEmpty ( $old_service_set_value ) || $this->_is_field_empty ( $old_subscriber_details, "voicemail_account" )) {
			$generated_number = $this->_generate_voicemail_account ( $connection );
			$update_param ["voicemail_account"] = $generated_number;
			$subscriber_details ["voicemail_account"] = $generated_number;
		}

		if (count ( $update_param ) > 0) {
			$update_param ["user_id"] = $subscriber_details ["user_id"];
			$update_param ["subscriber_id"] = $subscriber_details ["subscriber_id"];
			$update_param ["group_id"] = $subscriber_details ["group_id"];
			$update_param ["subscriber_type"] = $subscriber_details ["subscriber_type"];
			if (isset ( $subscriber_details ["msg_ip_address"] )) {
				$update_param ["msg_ip_address"] = $subscriber_details ["msg_ip_address"];
			}
			if (ProvUtility::isVoicemailServiceNone ( UtilityMethods::getValueFromArray ( $subscriber_details, "voicemail_service", "" ) )) {
				// Here use string(null), if we use null then subscriberdao::_build_update_query_and_param() could not identify it
				$update_param ["voicemail_server"] = "NULL";
				$update_param ["voicemail_number"] = "NULL";
				$update_param ["voice_mail_directory_number"] = "NULL";
				$update_param ["voicemail_pin"] = "NULL";
				$update_param ["voicemail_notification"] = ProvisioningConstant::VOICEMAIL_NOTIFICATION_OFF;
				$update_param ["msg_ip_address"] = "NULL";
			}
			$call_executed_list = array ();

			try {
				$connection->beginTransaction ();
				if (UtilityMethods::isEmpty ( $old_service_set_value ) || ! UtilityMethods::is_standalone_voicemail_menu_bundle ( $old_menu )) {
					SubscriberDao::update_subscriber_type ( $connection, $subscriber_details );
				}
				SubscriberDao::update_standalone_subscriber ( $connection, $update_param );
				if (isset ( $update_param ["sku"] )) {
					$this->_subscriber_invoice_details_for_update ( $connection, $product_diff_response_array, $subscriber_details, $group_details );
				}
				$this->_add_remove__subscriber_notices ( $connection, $group_details->group_id );

				if (! isset ( $old_subscriber_details ["voicemail_service"] )) {
					$old_subscriber_details ["voicemail_service"] = ProvisioningConstant::VOICEMAIL_SERVER_NONE;
				}

				// Perform A2 Call
				$individualProv = new models\external\prov\Individual ();
				/*
				 * If Voicemail Service is changed from Hosted -> NONE then
				 * delete the voicemail account
				 * else if voicemail service is changed from None -> Hosted then
				 * create voicemail account
				 * else if old voicemail account is Hosted then (same as new voicemial service)
				 * send Modify A2 Request
				 * else // old voicemail account is None (same as new voicemial service)
				 * No A2 Request
				 */
				if (isset ( $update_param ["voicemail_service"] ) && ProvUtility::isVoicemailServiceNone ( $update_param ["voicemail_service"] ) && ProvUtility::isVoicemailServiceHosted ( $old_subscriber_details ["voicemail_service"] )) {
					$this->_deleteVoicemailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				} else if (isset ( $update_param ["voicemail_service"] ) && ProvUtility::isVoicemailServiceHosted ( $update_param ["voicemail_service"] ) && ProvUtility::isVoicemailServiceNone ( $old_subscriber_details ["voicemail_service"] )) {
					$this->_saveVoicemailDetails ( $connection, $group_details, $subscriber_details, $individualProv, $call_executed_list );
				} else if (ProvUtility::isVoicemailServiceHosted ( $old_subscriber_details ["voicemail_service"] )) {
					if (isset ( $update_param ["service_set_value"] ) || count ( array_intersect_key ( $update_param, array_fill_keys ( $this->_modify_hosted_voicemail_fields, "" ) ) ) > 0) {
						// As per JIRA ACL-785 If the user leaves the v_VMpin empty on a modify, simply dont send v_VMpin, the backend will leave their pin alone.
						$update_subscriber_details = $subscriber_details;
						if (! isset ( $update_param ["voicemail_pin"] )) {
							unset ( $update_subscriber_details ["voicemail_pin"] );
						}
						$this->_updateVoicemailDetails ( $connection, $group_details, $update_subscriber_details, $individualProv, $call_executed_list );

						if (ProvUtility::isUreachDeviceType ( $group_details->voice_mail_device_type )) {
							$paProv = new models\external\prov\pa\Pa ();
							$response = $paProv->SetPhoneSettings ( $connection, $subscriber_details );
							if (is_string ( $response [ProvisioningConstant::A2_RESPONSE] ) && ! preg_match ( "/Failed/i", $response [ProvisioningConstant::A2_RESPONSE] )) {
								$call_executed_list [] = "SetPhoneSettings";
							}
						}
					}
				}

				DbConnector::commitTransaction ( $connection );
				if ($this->_isDebugEnabled ()) {
					$this->_debug ( " Update Successful for Non Provosion Details for Subscriber:" . $user_id );
				}
			} catch ( Exception $e ) {
				DbConnector::rollbackTransaction ( $connection );
				if ($this->_isErrorEnabled ()) {
					$this->_error ( "Updating Details for Standalone Subscriber Failed!", $e );
				}
				/*
				 * On Failure to update subscriber, perform the Rollback user updated in A2
				 *
				 */
				$this->_rollback_update_subscriber_details ( $connection, $group_details, $subscriber_details, $call_executed_list, $old_subscriber_details );
				if (is_a ( $e, 'models\external\prov\exception\CallFailedException' )) {
					return $this->_build_error_message ( $e->getCode (), $e->getMessage () );
				}
				return SubscriberValidator::build_error_message ( ApiResponseConstant::UPDATE_SUBSCRIBER_DETAILS_FAILED, null );
			}
		}  // end of if(count($update_param)>0)
		else {
			if ($this->_isDebugEnabled ()) {
				$this->_debug ( " No changes found to Update Standalone Details for Subscriber:" . $user_id );
			}
		} // end of else-if(count($update_param)>0)
		return true;
	}
	// end of method _update_standalone_subscriber_details()

	private function _add_remove__subscriber_notices($connection, $group_id) {
		$noticesfacade = new NoticesFacade ();
		// $noticesfacade->noticeupdate_for_no_inventory($connection, $group_id);
		$noticesfacade->noticeupdate_for_no_standalone_product ( $connection, $group_id );
		$noticesfacade->noticeupdate_for_nonstandalone_product ( $connection, $group_id );
	}
	private function _is_field_empty($subscriber_details, $field_name) {
		if ((! isset ( $subscriber_details [$field_name] )) || UtilityMethods::isEmpty ( $subscriber_details [$field_name] )) {
			return true;
		}
		return false;
	}
	private function _is_field_not_empty($subscriber_details, $field_name) {
		return ! $this->_is_field_empty ( $subscriber_details, $field_name );
	}

    /**
     * Internal Method to update fields in new subscriber details array
     * based on old subscriber details
     *
     * @param array $subscriberDetails
     * @param array $oldSubscriberDetails
     * @param array $fieldNames
     * @param array $arrayToPopulate
     *
     * @return void
     */
    private function _update_array_for_changes($subscriberDetails, $oldSubscriberDetails, $fieldNames, &$arrayToPopulate)
    {
        /*
         * if key is not in new then NO Change
         * if value for key is empty not in new and old value is not empty then Change
         */
        foreach ($fieldNames as $fieldName) {
            if (isset($subscriberDetails[$fieldName])) {
                if (
                    !isset($oldSubscriberDetails[$fieldName])
                    || UtilityMethods::isNotEqual(
                        $subscriberDetails[$fieldName], $oldSubscriberDetails[$fieldName])
                ) {

                    $arrayToPopulate[$fieldName] = $subscriberDetails[$fieldName];
                }
            }
        }
    }

	private function _reset_field_overriden(&$subscriber_details, $subscriber_over_ride_field_names) {
		foreach ( $subscriber_over_ride_field_names as $subscriber_field_name => $subscriber_over_ride_field_name ) {
			$subscriber_details [$subscriber_over_ride_field_name] = 0;
		}
	}

    /**
     * Internal method to fill subscriber detail attributes
     *
     * @param array $subscriberDetails
     * @param array $subscriberServiceFieldNames
     * @param array $siteInformation
     * @param array $siteFieldNames
     * @param array $subscriberOverrideFieldNames
     *
     * @return void
     */
    private function _is_servicefield_overriden(
        &$subscriberDetails,
        $subscriberServiceFieldNames,
        $siteInformation,
        $siteFieldNames,
        $subscriberOverrideFieldNames)
    {

        foreach ($subscriberOverrideFieldNames as $subscriberFieldName => $siteOverrideFieldName) {

            if (in_array($subscriberFieldName, SubscriberConstant::DO_NOT_OVERWRITE_FIELDS)) {
                continue;
            }

            // It is enough to check only field name
            // call_permission or call_forward_permission exists in the $subscriberDetails.
            if ((!isset($subscriberDetails['call_permission'])
                    || !isset($subscriberDetails['call_forward_permission']))
                && (is_array($subscriberServiceFieldNames)
                    && (in_array('call_permission', $subscriberServiceFieldNames)
                        || in_array('call_forward_permission', $subscriberServiceFieldNames)))
            ) {
                $this->setSubscriberCallPermissions($subscriberDetails, $subscriberFieldName);
            }

            if (UtilityMethods::isNotEmpty($siteFieldNames)) {
                $this->_is_field_overriden(
                    $subscriberDetails,
                    $subscriberFieldName,
                    $siteInformation[$siteFieldNames[$subscriberFieldName]],
                    $siteOverrideFieldName);
            } else {
                $this->_is_field_overriden(
                    $subscriberDetails,
                    $subscriberFieldName,
                    $siteInformation[$subscriberFieldName],
                    $siteOverrideFieldName);
            }
        }
    }

	private function _is_field_overriden(&$subscriber_details, $subscriber_field_name, $field_site_value, $override_field_name) {
		if (isset ( $subscriber_details [$subscriber_field_name] )) {
			if (UtilityMethods::isNotEmpty ( $subscriber_details [$subscriber_field_name] ) && UtilityMethods::isNotEqual ( $subscriber_details [$subscriber_field_name], $field_site_value )) {
				$subscriber_details [$override_field_name] = 1;
				return;
			}
		}
		$subscriber_details [$subscriber_field_name] = $field_site_value;
	}
	public function _unset_fields_based_on_service_set(&$subscriber_details) {
		$service_set_value = $subscriber_details ["service_set_value"];
		$menu = $subscriber_details ["menu"];
		$unset_fields_array = array ();
		if (UtilityMethods::isNotEmpty ( $service_set_value )) {
			if (UtilityMethods::is_sip_pbx_basic_menu_bundle ( $menu )) {
				$unset_fields_array = array_merge ( $unset_fields_array, $this->_voip_fields );
				$unset_fields_array = array_merge ( $unset_fields_array, array (
						"timezone",
						"email"
				) );
			} // end of if(sip pbx basic)
			elseif (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu ) || UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
				$unset_fields_array = array_merge ( $unset_fields_array, array (
						"devices",
						"device_password_state",
						"device_password",
						"voip_alias"
				) );
			} // end of if(sip pbx routing)
			elseif (! UtilityMethods::is_configured_menu_bundle ( $menu )) {
				$unset_fields_array = array_merge ( $unset_fields_array, $this->_voip_fields );
			} // end of if(NOT voip service)

			if (! UtilityMethods::is_voicemail_menu_bundle ( $menu )) {
				$unset_fields_array = array_merge ( $unset_fields_array, $this->_voicemail_fields );
			} // end of if(NOT voicemail service)

			if (! UtilityMethods::is_meetme_menu_bundle ( $menu )) {
				$unset_fields_array = array_merge ( $unset_fields_array, $this->_meetme_fields );
			}

			if (! UtilityMethods::is_callgrab_menu_bundle ( $menu )) {
				$unset_fields_array = array_merge ( $unset_fields_array, $this->_callgrab_fields );
			}

			if (! UtilityMethods::is_mobility_menu_bundle ( $menu )) {
				$unset_fields_array = array_merge ( $unset_fields_array, $this->_mep_fields );
			} // end of if(NOT mobility service)

			if (! UtilityMethods::is_smart_office_video_collab_menu_bundle ( $menu ) && ! UtilityMethods::is_smart_office_web_collab_menu_bundle ( $menu )) {
				$unset_fields_array = array_merge ( $unset_fields_array, $this->_smart_office_fields );
			}
            if (!(UtilityMethods::is_standalone_voicemail_menu_bundle($menu)
                || UtilityMethods::isLiveSupportInboundVoiceMenuBundle($menu)
                || UtilityMethods::isMsTeamsMenuBundle($menu))) {
				$unset_fields_array = array_merge ( $unset_fields_array, $this->_standalone_voicemail_fields );
				if (! UtilityMethods::is_pbx_menu_bundle ( $menu )) {
					$subscriber_details ["subscriber_type"] = ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED;
				}
			} // end of if(NOT standalone VM)
		} else {
			$unset_fields_array = array_merge ( $unset_fields_array, $this->_common_prov_fields );
			$unset_fields_array = array_merge ( $unset_fields_array, $this->_voip_fields );
			$unset_fields_array = array_merge ( $unset_fields_array, $this->_voicemail_fields );
			$unset_fields_array = array_merge ( $unset_fields_array, $this->_meetme_fields );
			$unset_fields_array = array_merge ( $unset_fields_array, $this->_callgrab_fields );
			$unset_fields_array = array_merge ( $unset_fields_array, $this->_mep_fields );
			$unset_fields_array = array_merge ( $unset_fields_array, $this->_standalone_voicemail_fields );
		}
		$this->_reset_fields ( $subscriber_details, $unset_fields_array );
	}

	// end of method _unset_fields_based_on_service_set
	public function _verify_override_options(&$subscriber_details, $site_service_information) {
		$service_set_value = $subscriber_details ["service_set_value"];
		$menu = $subscriber_details ["menu"];

		$this->_reset_field_overriden ( $subscriber_details, $this->_common_prov_over_ride_fields );
		$this->_reset_field_overriden ( $subscriber_details, $this->_voip_over_ride_fields );
		$this->_reset_field_overriden ( $subscriber_details, $this->_voicemail_over_ride_fields );
		$this->_reset_field_overriden ( $subscriber_details, $this->_mep_over_ride_fields );
		$this->_reset_field_overriden ( $subscriber_details, $this->_standalone_voicemail_over_ride_fields );

		if (UtilityMethods::isNotEmpty ( $service_set_value ) && ! UtilityMethods::is_sip_pbx_basic_menu_bundle ( $menu )) {
			$this->_is_servicefield_overriden ( $subscriber_details, $this->_common_prov_fields, $site_service_information, null, $this->_common_prov_over_ride_fields );
			if ($subscriber_details ["is_timezone_over_ride"] !== 1) {
				$subscriber_details ["timezone_id"] = $site_service_information ["timezone_id"]; // Use Site Timezone Id
			}

			if (UtilityMethods::is_configured_menu_bundle ( $menu )) {
				$this->_is_servicefield_overriden ( $subscriber_details, $this->_voip_fields, $site_service_information, null, $this->_voip_over_ride_fields );
			} // end of voip service

			if (UtilityMethods::is_sip_pbx_routing_menu_bundle ( $menu )) {
				$this->_is_servicefield_overriden ( $subscriber_details, $this->_sip_pbx_routing_fields, $site_service_information, null, $this->_voip_over_ride_fields );
			} // end of sip pbx routing

			if (UtilityMethods::is_sip_pbx_calling_menu_bundle ( $menu )) {
				$this->_is_servicefield_overriden ( $subscriber_details, $this->_sip_pbx_calling_fields, $site_service_information, null, $this->_voip_over_ride_fields );
			} // end of sip pbx routing

			if (UtilityMethods::is_voicemail_menu_bundle ( $menu )) {
				$this->_is_servicefield_overriden ( $subscriber_details, $this->_voicemail_fields, $site_service_information, null, $this->_voicemail_over_ride_fields );
			} // end of voicemail service

			if (UtilityMethods::is_mobility_menu_bundle ( $menu )) {
				$this->_is_servicefield_overriden ( $subscriber_details, $this->_mep_fields, $site_service_information, $this->_site_mep_fields, $this->_mep_over_ride_fields );
			} // end of mobility service

			if (UtilityMethods::is_standalone_voicemail_menu_bundle ( $menu )) {
				$this->_is_servicefield_overriden ( $subscriber_details, $this->_standalone_voicemail_fields, $site_service_information, null, $this->_standalone_voicemail_over_ride_fields );
				if ($subscriber_details ["is_voicemail_system_over_ride"] !== 1) {
					$subscriber_details ["voicemail_device_id"] = $site_service_information ["voicemail_device_id"]; // Use Site VM Device Id
				}
			} // end of if(standalone VM)
		} // end of if(UtilityMethods::isNotEmpty($subscriber_details["service_set_value"]))
		$this->_unset_fields_based_on_service_set ( $subscriber_details );
	}
    // end of _verify_override_options() method

    /**
     * Set subscriber type.
     *
     * @param array $subscriberDetails
     * @return void
     */
    public function _set_subscriber_type(&$subscriberDetails)
    {
        $serviceSetValue = $subscriberDetails['service_set_value'];
        $menu = $subscriberDetails['menu'];
        if (UtilityMethods::isEmpty($serviceSetValue)) {
            $subscriberDetails['subscriber_type'] = ProvisioningConstant::SUBSCRIBER_TYPE_NON_PROVISION;
        } elseif (UtilityMethods::isSipTrunkSubscriberType($menu)) {
            $subscriberDetails['subscriber_type'] = ProvisioningConstant::SUBSCRIBER_TYPE_SIP_TRUNK;
        } elseif (UtilityMethods::isConfiguredStandaloneSubscriberType($menu)) {
            $subscriberDetails['subscriber_type'] = ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED_STANDALONE;
        } else {
            $subscriberDetails['subscriber_type'] = ProvisioningConstant::SUBSCRIBER_TYPE_CONFIGURED;
        }
    }

	// end of _set_subscriber_type()
	public function _flatten_parameter($param_array) {
		$subscriber_details = array ();
		if (isset ( $param_array ["identity_details"] )) {
			$identity_details = $param_array ["identity_details"];
			foreach ( $identity_details as $key => $value ) {
				$subscriber_details [$key] = $identity_details [$key];
			}
		}
		if (isset ( $param_array ["settings"] )) {
			$settings = $param_array ["settings"];
			foreach ( $settings as $key => $value ) {
				$subscriber_details [$key] = $settings [$key];
			}
		}
		if (isset ( $param_array ["advanced_settings"] )) {
			$advanced_settings = $param_array ["advanced_settings"];
			foreach ( $advanced_settings as $key => $value ) {
				$subscriber_details [$key] = $advanced_settings [$key];
			}
		}
		if (isset ( $param_array ["contact_center_details"] ) && ! empty ( $param_array ["contact_center_details"] ) > 0) {
			$contact_center_details = $param_array ["contact_center_details"];
			foreach ( $contact_center_details as $key => $value ) {
				$subscriber_details [$key] = $contact_center_details [$key];
			}
		}
		if(isset($param_array["claas_identity_details"])){
		    $claas_identity_details = $param_array["claas_identity_details"];
		    foreach ( $claas_identity_details as $key => $value){
		        $subscriber_details [$key] = $claas_identity_details [$key];
		    }
		}
        if (isset($param_array['is_ls_request']) && !empty($param_array['is_ls_request'])) {
            $subscriber_details['is_ls_request'] = $param_array['is_ls_request'];
		}

        if (array_key_exists('fromData', $param_array)) {
            $subscriber_details['fromData'] = $param_array['fromData'];
        }

        if (array_key_exists('callRecordingSettings', $param_array)) {
            $subscriber_details['callRecordingSettings'] = $param_array['callRecordingSettings'];
        }

        if (array_key_exists('callRecordingDetails', $param_array)) {
            $subscriber_details['callRecordingDetails'] = $param_array['callRecordingDetails'];
        }

        if (array_key_exists('emergencyAddress', $param_array)) {
            $subscriber_details['emergencyAddress'] = $param_array['emergencyAddress'];
        }

        if ($this->fromMigration && array_key_exists('voicemail_account', $param_array)) {
            $subscriber_details['voicemail_account'] = $param_array['voicemail_account'];
        }

        if ($this->fromMigration && array_key_exists('callgrab_number', $param_array)) {
            $subscriber_details['callgrab_number'] = $param_array['callgrab_number'];
        }

		return $subscriber_details;
	}

	// end of _flatten_parameter()
	private function _reset_fields(&$subscriber_details, $reset_fields_array) {
		foreach ( $reset_fields_array as $keyNames ) {
			$subscriber_details [$keyNames] = null;
		}
	}
	private function _copy_default_values(&$subscriber_details, $fields_array, $old_subscriber_details) {
		foreach ( $fields_array as $field_name ) {
			if (isset ( $old_subscriber_details [$field_name] )) {
				$subscriber_details [$field_name] = $old_subscriber_details [$field_name];
			}
		}
	}
	public function get_subscriber_list($parameter_array, $group_id, $group_type) {
		try {

			$response_array = array ();
			$dashboard_degistration = new DashboardRegistrationFacade;
			$search_text = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SEARCH_KEYWORD, "" );
			$limit = UtilityMethods::getPageLimit ( $parameter_array, PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE );
			$offset = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_OFFSET, 0 );
			$order_by = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_BY, '' );
			$order_type = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_ORDER, CommonConstant::SORTING_ORDER_ASCENDING );
			$fields = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_FIELDS, '*' );
			$selected_subscriber = UtilityMethods::getValueFromArray ( $parameter_array, "selected_subscriber", NULL );
			$selected_only = UtilityMethods::getValueFromArray ( $parameter_array, "selected_only", NULL );
            $selected_directory = UtilityMethods::getValueFromArray($parameter_array, "selected_directory", NULL);
			$connection = DbConnector::getConnection ();
            $total_count = SubscriberDao::getCount($connection, $group_id, $search_text, ProvisioningConstant::SUBSCRIBER_TYPE_CONTACT_CENTER, true);
            $response_array["subscriberlist"] = SubscriberDao::get_subscriber_list(
                $connection,
                $group_id,
                $offset,
                $limit,
                $search_text,
                $order_by,
                $order_type,
                $fields,
                $selected_subscriber,
                $selected_only
            );
			$response_array ["subscriberlist"] = $dashboard_degistration->get_subscribers_registration_status($connection, $response_array ["subscriberlist"]);
			if ($order_by == "check_sync_status"){
				$response_array ["subscriberlist"] = $this->get_subscribers_sync_status($response_array ["subscriberlist"])['subscriberlist'];
				// if search_text filter result.
                if (isset ($search_text) || UtilityMethods::isClient() && UtilityMethods::isNotEmpty($selected_directory)) {
					if (UtilityMethods::isNotEmpty ( $search_text ) || UtilityMethods::isClient ()) {
						$response_array ["subscriberlist"] = array_filter ( $response_array ["subscriberlist"], function ($value) {
							global $search_text;
							return (preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["check_sync_status"] ) ) || preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["user_id"] ) ) || preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["first_name"] ) ) || preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["last_name"] ) ) || preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["site_identifier"] ) ) || preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["number"] ) ) || preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["service_access_status"] ) ) || preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["scheduled_time"] ) ) || preg_match ( "*" . strtolower ( $search_text ) . "*", strtolower ( $value ["info"] ) ));
						} );
					}
				}

				// perform reordering of columns.
				if(isset($order_by) && UtilityMethods::isNotEmpty($order_by)){
					if(UtilityMethods::isNotEmpty($order_type)){
						if(UtilityMethods::isEqual($order_type, CommonConstant::SORTING_ORDER_ASCENDING, true)){
							$sort_type = SORT_ASC;
						}elseif(UtilityMethods::isEqual($order_type, CommonConstant::SORTING_ORDER_DESCENDING, true)){
							$sort_type = SORT_DESC;
						}
						$response_array ["subscriberlist"] = UtilityMethods::array_sort($response_array ["subscriberlist"], $order_by, $sort_type);
					}
				}

				usort($response_array["subscriberlist"], function($a, $b)
				{
				    return strcmp($a['check_sync_status'], $b['check_sync_status']);
				});
				if($parameter_array['sort_order'] == "desc"){
					$response_array ["subscriberlist"] = array_reverse($response_array["subscriberlist"]);
				}

				// get result from offset.
				// limit count of results.
				$response_array ["subscriberlist"] = array_slice($response_array ["subscriberlist"], $offset, $limit);
			}

			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $response_array ["subscriberlist"];
			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = $total_count;
			$response_array [CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $offset;
			$response_array [CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE;
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting Subscriber list  failed!", $e );
			}
			throw $e;
		}
	}

    /**
     * Method to get subscriber list for advanced search
     *
     * @param array $parameterArray
     *
     * @return array
     * @throws Exception
     */
    public function getSubscriberListForAdvancedSearch($parameterArray)
    {
        try {
            $responseArray = [];
			$groupId = CommonHelper::getContextValue("group_id");
            $searchText = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_SEARCH_KEYWORD, "");
            $limit = UtilityMethods::getPageLimit($parameterArray, PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE );
            $offset = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_OFFSET, CommonConstant::DEFAULT_OFFSET);
            $orderBy = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_SORT_BY, '' );
            $orderType = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_SORT_ORDER, CommonConstant::SORTING_ORDER_ASCENDING);
            $fields = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_FIELDS, '*' );

            $connection = DbConnector::getConnection ();
            $subscriberlist = SubscriberDao::getSubscriberListForAdvancedSearch(
                $connection,
                $groupId,
                $offset,
                $limit,
                $searchText,
                $orderBy,
                $orderType,
                $fields
            );

            $responseArray[CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $subscriberlist;
            $responseArray[CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = count($subscriberlist);
            $responseArray[CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $offset;
            $responseArray[CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE;
            return $responseArray;
        } catch(Exception $e) {
            $this->_error(" SubscriberFacade -> getSubscriberListForAdvancedSearch is failed! (Group ID: "
                . $groupId . ")  Error message: ", $e);
            throw $e;
        }
    }

    /**
     * Get list of subscribers that has devices assigned
     *
     * @param array $parameterArray
     * @param int $groupId
     *
     * @return array
     * @throws Exception
     */
    public function getSubscriberListAssignedOnly($parameterArray, $groupId)
    {
        try {
            $connection = DbConnector::getConnection();
            $searchText = UtilityMethods::getValueFromArray(
                $parameterArray,
                CommonConstant::QUERY_PARAM_SEARCH_KEYWORD,
                ''
            );
            $limit = UtilityMethods::getPageLimit($parameterArray, PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE);
            $offset = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_OFFSET, 0);
            $orderBy = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_SORT_BY, '');
            $orderType = UtilityMethods::getValueFromArray(
                $parameterArray,
                CommonConstant::QUERY_PARAM_SORT_ORDER,
                CommonConstant::SORTING_ORDER_ASCENDING
            );
            $selectedSubscriber = UtilityMethods::getValueFromArray($parameterArray, 'selected_subscriber', NULL);

            $total_count = SubscriberDao::getCountAssignedSubscribers($connection, $groupId, $searchText);
            $responseArray["subscriberlist"] = SubscriberDao::getSubscriberListAssignedOnly(
                $connection,
                $groupId,
                $offset,
                $limit,
                $searchText,
                $orderBy,
                $orderType,
                $selectedSubscriber
            );
            $responseArray[CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $responseArray['subscriberlist'];
            $responseArray[CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = $total_count;
            $responseArray[CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $offset;
            $responseArray[CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE;
            return $responseArray;
        } catch (Exception $e) {
            $inputs = [
                'GROUP_ID' => $groupId
            ];
            $this->_error($this->_getVarDump($inputs) . 'Getting Subscriber list  failed!', $e);
            throw $e;
        }
    }

	public function is_phonebutton_config_enabled($group_id, $subscriber_id, $device_management=false) {
	    try {
	        $connection = DbConnector::getConnection ();
	        $response_array = GroupDao::is_group_phonebutton_config_enabled($connection,$group_id);
            // don't bother checking the subscriber's devices if there's no SBP support for this customer
	        if($response_array['is_phonebutton_enabled'] == 1 && !$device_management) {
	            $subscriber_details = SubscriberDao::get_subscriber_details_by_user_id($connection, $subscriber_id, $group_id, "subscriber_id");
                if (UtilityMethods::isEmpty ($subscriber_details)) {
                    $response["ERROR_CODE"] = ApiResponseConstant::SUBSCRIBER_USER_ID_NOT_EXIST;
                    return $response;
                }
                $subscriber_devices = SubscriberDao::get_subscriber_devices_for_button_keys($connection, $subscriber_details['subscriber_id']);
                if(count($subscriber_devices) <= 0) {
                    $response_array['is_phonebutton_enabled'] = 0;
                }
            }

	        return $response_array;
	    } catch ( Exception $e ) {
	        // catching Error
	        if ($this->_isErrorEnabled ()) {
	            $inputs = array (
	                "GROUP_ID" => $group_id
	            );
	            $this->_error ( $this->_getVarDump ( $inputs ) . "Getting Phone Button Enabling status failed!", $e );
	        }
	        throw $e;
	    }
	}
	public function validate_phone_button_supported_for_mac($mac_address) {
	    try {
	        $connection = DbConnector::getConnection ();
	        $response_array = SubscriberDao::validate_phone_button_supported_for_mac($connection,$mac_address);
	        if (UtilityMethods::isEmpty ($response_array)) {
	            $response["ERROR_CODE"] = ApiResponseConstant::INVALID_MAC_ADDRESS;
	            return $response;
	        }
	        return $response_array;
	    } catch ( Exception $e ) {
	        // catching Error
	        if ($this->_isErrorEnabled ()) {
	            $inputs = array (
	                "mac_address" => $mac_address
	            );
	            $this->_error ( $this->_getVarDump ( $inputs ) . "Validating Phone Button Configuration status failed!", $e );
	        }
	        throw $e;
	    }
	}


	public function allow_eup_button_config($subscriber_id) {
	    try {
	        $connection = DbConnector::getConnection ();
	        $group_id = CommonHelper::getContextValue('group_id');
	        $phonebutton_config_is_enabled = $this->is_phonebutton_config_enabled($group_id, $subscriber_id);
	        if(array_key_exists("ERROR_CODE", $phonebutton_config_is_enabled)) {
	            return $phonebutton_config_is_enabled;
            }
	        if($phonebutton_config_is_enabled['is_phonebutton_enabled'] == '1'){
	           $response_array = SubscriberDao::allow_eup_button_config($connection,$subscriber_id);
	        } else {
	            $response_array = $phonebutton_config_is_enabled;
	        }
	        return $response_array;
	    } catch ( Exception $e ) {
	        // catching Error
	        if ($this->_isErrorEnabled ()) {
	            $inputs = array (
	                "GROUP_ID" => $group_id
	            );
	            $this->_error ( $this->_getVarDump ( $inputs ) . "Getting Phone Button EUP Portal Enabling status failed!", $e );
	        }
	        throw $e;
	    }
	}

	public function get_subscriber_devices($subscriber_id) {
	    try {
	        $group_id = CommonHelper::getContextValue('group_id');
	        $connection = DbConnector::getConnection ();
	        $subscriber_details = SubscriberDao::get_subscriber_details_by_user_id($connection, $subscriber_id, $group_id, "subscriber_id, password, domain, prov_system_id" );
	        if (UtilityMethods::isEmpty ($subscriber_details)) {
	            $response["ERROR_CODE"] = ApiResponseConstant::SUBSCRIBER_USER_ID_NOT_EXIST;
	            return $response;
	        }
	        $subscriber_devices = SubscriberDao::get_subscriber_devices($connection, $subscriber_details['subscriber_id']);
	        return $subscriber_devices;
	    } catch ( Exception $e ) {
	        // catching Error
	        if ($this->_isErrorEnabled ()) {
	            $inputs = array (
	                "GROUP_ID" => $group_id
	            );
	            $this->_error ( $this->_getVarDump ( $inputs ) . "Getting Subscriber devices failed!", $e );
	        }
	        throw $e;
	    }
	}

	public function get_subscriber_list_group($parameter_array) {
	    try {
	        $connection = DbConnector::getConnection ();
	        $group_id = CommonHelper::getContextValue('group_id');
	        $response_array = array();
	        $search_text = UtilityMethods::getValueFromArray ($parameter_array, CommonConstant::QUERY_PARAM_SEARCH_KEYWORD, "");
	        $limit = UtilityMethods::getPageLimit ( $parameter_array, PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE );
	        $offset = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_OFFSET, 0 );
	        $order_by = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_BY, '' );
	        $order_type = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_ORDER, CommonConstant::SORTING_ORDER_ASCENDING );
	        $fields = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_FIELDS, '*' );
            $total_count = SubscriberDao::getCount($connection, $group_id, $search_text, ProvisioningConstant::SUBSCRIBER_TYPE_CONTACT_CENTER, true);
	        $subscriber_details = SubscriberDao::get_subscriber_list_group($connection, $group_id, $search_text, $order_by, $order_type,$offset, $limit);
	        if (UtilityMethods::isEmpty ($subscriber_details)) {
	            $response["ERROR_CODE"] = ApiResponseConstant::SUBSCRIBER_USER_ID_NOT_EXIST;
	            return $response;
	        }
	        $response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $subscriber_details;
	        $response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = $total_count;
	        $response_array [CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $offset;
	        $response_array [CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE;
	        $response_array ["subscriberlist"] = $subscriber_details;
	        return $response_array;
	    } catch ( Exception $e ) {
	        // catching Error
	        if ($this->_isErrorEnabled ()) {
	            $inputs = array (
	                "GROUP_ID" => $group_id
	            );
	            $this->_error ( $this->_getVarDump ( $inputs ). "Getting Subscriber list failed!", $e );
	        }
	        throw $e;
	    }
	}

	public function get_subscriber_list_for_mida_download($parameter_array, $group_id) {
		try {
			$response_array = array ();
			$connection = DbConnector::getConnection ();
			$response_array ["subscriberlist"] = SubscriberDao::get_subscriber_list_for_mida_download( $connection, $group_id );
			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $response_array ["subscriberlist"];
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting Subscriber list  failed!", $e );
			}
			throw $e;
		}
	}

	// end of method get_subscriber_list()

    /**
     * Method to list subscribers for root level subscriber search
     *
     * @param array $parameterArray
     *
     * @return array
     */
    public function getSubscriberListForRoot($parameterArray)
    {
        try {
            $response = [];
            $searchText = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_SEARCH_KEYWORD, "");
            $limit = UtilityMethods::getPageLimit($parameterArray, PageSizeConstant::SYSTEM_SUBSCRIBER_DEFAULT_PAGE_SIZE);
            $offset = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_OFFSET, 0);
            $orderBy = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_SORT_BY, '');
            $orderType = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_SORT_ORDER, CommonConstant::SORTING_ORDER_ASCENDING);
            $fields = UtilityMethods::getValueFromArray($parameterArray, CommonConstant::QUERY_PARAM_FIELDS, '*');
            $connection = DbConnector::getConnection();

            if (SessionUtility::isContextGroupTypePartner()) {
                $subscriberList = SubscriberDao::getSubscriberListForPartner(
                    $connection,
                    $offset,
                    $limit,
                    $searchText,
                    $orderBy,
                    $orderType,
                    $fields
                );
            } else {
                $subscriberList = SubscriberDao::getSubscriberListForRoot(
                    $connection,
                    $offset,
                    $limit,
                    $searchText,
                    $orderBy,
                    $orderType,
                    $fields
                );
            }
            $response[CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $subscriberList;
            $response[CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = count($subscriberList);
            $response[CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $offset;
            $response[CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = $limit;
            return $response;
        } catch (Exception $e) {
            $this->_error( " SubscriberFacade -> getSubscriberListForRoot -> Getting Subscriber list for ROOT failed!", $e);
            throw $e;
        }
    }

	// end of method get_subscriber_list()
	public function get_available_inventory_count() {
		try {
			$product_count_array = $this->get_inventory_products_for_provisioning ( array () );
			$product_count = $product_count_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT];

			return $product_count;
		} catch ( Exception $e ) {
			if ($this->_isErrorEnabled ()) {
				$group_id = CommonHelper::getContextValue ( 'group_id' );
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting Product list for provision failed!", $e );
			}
			throw $e;
		}
	}

	// Method to get inventory products for provisioning
	public function get_inventory_products_for_provisioning($parameter_array, $group_details = NULL) {
		$response_array = array ();
		$connection = DbConnector::getConnection ();

		if (UtilityMethods::isEmpty ( $group_details )) {
			$group_id = CommonHelper::getContextValue ( 'group_id' );
			$group_type = CommonHelper::getContextValue ( 'group_type' );
			$group_details = $this->get_group_provision_details ( $connection, $group_id );
		}

		try {
			$filter_array = array ();
			$filter_array ['limit'] = UtilityMethods::getPageLimit ( $parameter_array, PageSizeConstant::PROVISION_INVENTORY_DEFAULT_PAGE_SIZE );
			$filter_array ['offset'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_OFFSET, 0 );
			$filter_array ['fields'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_FIELDS, implode ( ',', ListFieldConstant::$prov_product_fields_list ) );
			$filter_array ['sort_by'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_BY, NULL );
			$filter_array ['sort_order'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_ORDER, CommonConstant::SORTING_ORDER_ASCENDING );
			$filter_array ['search_text'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SEARCH_KEYWORD, NULL );

			$is_configured_standalone = UtilityMethods::isDomainConfiguredStandalone ( $group_details->top_level_domain_status );
			$only_available = true;
			$subscriber_product_ids = "";
			$filter_array ['fetch_only_configured'] = FALSE;
			$filter_array ['fetch_only_configured_standalone'] = FALSE;
			$filter_array ['fetch_only_sip_trunk'] = FALSE;
			$filter_array ['fetch_without_sip_trunk'] = FALSE;
			$filter_array ['fetch_without_configured_standalone'] = FALSE;
			if (array_key_exists ( "subscriber_user_id", $parameter_array )) {
                $subscriber_details = SubscriberDao::get_subscriber_details_by_user_id(
                    $connection,
                    $parameter_array['subscriber_user_id'],
                    $group_id,
                    'subscriber_id, subscriber_type, product_ids, service_set_value'
                );
				if ($subscriber_details) {
					$only_available = false;
					$subscriber_product_ids = $subscriber_details ['product_ids'];
				}
				if (ProvUtility::isSubscriberConfigured ( $subscriber_details ['subscriber_type'] )) {
					$filter_array ['fetch_only_configured'] = TRUE;
				} elseif (ProvUtility::isSubscriberSipTrunk ( $subscriber_details ['subscriber_type'] )) {
					$filter_array ['fetch_only_sip_trunk'] = TRUE;
				} elseif (ProvUtility::isSubscriberStandalone ( $subscriber_details ['subscriber_type'] )) {
					$filter_array ['fetch_only_configured_standalone'] = TRUE;
				} else {
					$filter_array ['fetch_without_sip_trunk'] = TRUE;
				}
			} else {

				$pbx_site_details = SiteDao::get_site_list_for_subscribers ( $connection, $group_id, SiteConstant::SITE_TYPE_PBX );
				if (UtilityMethods::isEmpty ( $pbx_site_details ["site_list"] )) {
					$filter_array ['fetch_without_sip_trunk'] = TRUE;
				} else {
					$site_count = SiteDao::get_count_for_subscriber ( $connection, $group_id, SiteConstant::SITE_TYPE_PBX );
					if ($site_count == 0) {
						$filter_array ['fetch_only_sip_trunk'] = TRUE;
					}
				}
			}

			if ($is_configured_standalone) {
				$filter_array ['fetch_only_configured_standalone'] = $is_configured_standalone;
			} else {
				$voicemail_device_count = VoicemailDeviceDao::get_voicemail_devices_active_count ( $connection, $group_id );
				if ($voicemail_device_count == 0) {
					$filter_array ['fetch_without_configured_standalone'] = TRUE;
				}
			}
			$filter_array ['only_available'] = $only_available;
			$filter_array ['subscriber_product_ids'] = $subscriber_product_ids;
			$inventory_product_response = InventoryItemDao::get_inventory_product_for_new_provisioning ( $connection, $group_id, $filter_array );
            if (UtilityMethods::isMSTeamsAvailable($group_details->group_identifier)) {
                foreach ($inventory_product_response['inventory_product_list'] as &$item) {
                    if (UtilityMethods::isMsTeamsServiceBundle($item['service_set_value'])) {
                        $item['msTeamsEmergencyDetailsAvailable'] = MS_TEAMS_EMERGENCY_ADDRESS_AVAILABLE;
                        continue;
                    }
                }
            }

			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $inventory_product_response ['inventory_product_list'];
			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = $inventory_product_response ["count"];
			$response_array [CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $filter_array ['offset'];
			$response_array [CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = PageSizeConstant::PROVISION_INVENTORY_DEFAULT_PAGE_SIZE;
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting Product list for provision failed!", $e );
			}
			throw $e;
		}
	}

	// Method to get list for advance settings
	public function get_advance_settings_population_list() {
		$connection = DbConnector::getConnection ();
		$group_id = CommonHelper::getContextValue ( 'group_id' );

		try {
			$group_details = $this->get_group_provision_details ( $connection, $group_id );
			$response_array ['timezone_array'] = TimezoneDao::get_timezone_list_for_client ( $connection );
			$response_array ['call_permission_array'] = $this->get_voice_classOfService ( $connection, $group_details );

			$domainProv = new models\external\prov\Domain ();
			$prov_system_id = $this->get_first_member_provisioning_system_id ( $connection, $group_details->group_id );
			if (ProvUtility::isDomainStatusConfiguredStandalone ( $group_details->top_level_domain_status )) {
				$response_array ['location_array'] = array ();
			} else {
				$response_array ['location_array'] = $domainProv->getAllLocationHierarchyForDomain ( $connection, $group_details, $prov_system_id );
			}

			$response_array ['mobility_profile_array'] = $this->get_mep_profile_list ( $connection, $group_details );
			$response_array ['voicemail_service_array'] = array (
					ProvisioningConstant::VOICEMAIL_SERVER_NONE,
					ProvisioningConstant::VOICEMAIL_SERVER_HOSTED,
					ProvisioningConstant::VOICEMAIL_SERVER_PREMISE
			);
			$response_array ['standalone_voicemail_service_array'] = array (
					ProvisioningConstant::VOICEMAIL_SERVER_NONE,
					ProvisioningConstant::VOICEMAIL_SERVER_HOSTED
			);
			$response_array ['autoattendant_voicemail_service_array'] = array (
					ProvisioningConstant::VOICEMAIL_SERVER_HOSTED,
					ProvisioningConstant::VOICEMAIL_SERVER_PREMISE
			);
			$response_array ['voicemail_device_array'] = VoicemailDeviceDao::get_voicemail_list_for_dropdown ( $connection, $group_id );

			$response_array ['number_display_option'] = $group_details->number_display_option;
			$smart_office_group_id = $this->_get_smart_office_group_id ( $group_details );
			$response_array ['conference_extn_prefix'] = SmartOfficeConfigurationDao::get_conference_access_prefix ( $connection, $smart_office_group_id, ProvisioningConstant::SMART_OFFICE_VIDEO_COLLAB );
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting advance settings list failed!", $e );
			}
			throw $e;
		}
	}

	/**
	 * ACL-1446 PMC password required for all devices?
	 * As discussed, removed all validation and visibity conditions
	 * This method not called by anyone
	 */
	public function is_device_password_visible($subscriber_user_id = NULL) {
		$connection = DbConnector::getConnection ();
		$group_id = CommonHelper::getContextValue ( 'group_id' );
		/**
		 * ACL-1387 Device Password Improvements
		 * 1.
		 * Need to verify the domain has a PMC profile, if so all users are allowed to set PMC password as they do today.
		 * There should be no tie to the number of devices a customer has.
		 * If a customer has 0 or more devices with a PMC profile portal will allow PMC password for all users.
		 * 2. In addition the auto attendants need to have PMC password shown on their screen.
		 */
		$response ["device_password_visible"] = FALSE;
		if (UtilityMethods::isNotEmpty ( $subscriber_user_id )) {
			$subscriber_details = SubscriberDao::get_subscriber_details_by_user_id ( $connection, $subscriber_user_id, $group_id, "subscriber_id, domain, prov_system_id" );
			$top_level_domain = $subscriber_details ["domain"];
			$prov_system_id = $subscriber_details ["prov_system_id"];
		} else {
			$top_level_domain = GroupA2DomainConfigDao::get_single_result_by_group_id ( $connection, "top_level_domain", $group_id );
			$prov_system_id = $this->get_first_member_provisioning_system_id ( $connection, $group_id );
		}
		$domainProv = new models\external\prov\Domain ();
		$is_pmc_pass_policy_enabled = $domainProv->getPMCPasswordPolicyForDomain ( $connection, $top_level_domain, $prov_system_id );
		$response ["device_password_visible"] = $is_pmc_pass_policy_enabled;
		return $response;
	}
	public function is_hotdesking_devices_exist($parameter) {
		try {
			$connection = DbConnector::getConnection ();
			$group_id = CommonHelper::getContextValue ( 'group_id' );
			$response ["hotdesk_password_visible"] = TerminalsDao::is_hotdesking_devices_exist ( $connection, $group_id );
			return $response;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting is_hotdesking_devices_exist failed!", $e );
			}
			throw $e;
		}
	}

	// method to clear subscriber hotdesk password
	public function clear_hotdesk_password($user_id) {
		try {
			$connection = DbConnector::getConnection ();
			$group_id = CommonHelper::getContextValue ( 'group_id' );
			$subscriber_details = SubscriberDao::get_subscriber_details_by_user_id ( $connection, $user_id, $group_id, "subscriber_id" );
			if (UtilityMethods::isEmpty ( $subscriber_details )) {
				return $this->_build_error_message ( ApiResponseConstant::RESOURCE_NOT_EXISTS, "" );
			}
			SubscriberDao::clear_hotdesk_password ( $connection, $subscriber_details ["subscriber_id"], $group_id );
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "clear_hotdesk_password failed!", $e );
			}
			throw $e;
		}
	}

	// Method to get multi provisioning system list
	public function get_multi_prov_system_list() {
		$connection = DbConnector::getConnection ();
		$group_id = CommonHelper::getContextValue ( 'group_id' );

		try {
			$group_details = $this->get_group_provision_details ( $connection, $group_id );
			$cluster_details = array ();
			if ($group_details->allow_multiple_prov_system) {
				$cluster_details = ProvisionSystemDao::get_provSystem_list_by_identifier ( $connection, $group_details->group_identifier );
			}

			$response_array ['provisioning_system'] = $cluster_details;
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting multi prov system list failed!", $e );
			}
			throw $e;
		}
	}

	// method to get the voice cos
	public function get_voice_classOfService($connection, $group_details) {
		try {
			$cos_array = array ();
			if (ProvUtility::isDomainStatusConfiguredStandalone ( $group_details->top_level_domain_status )) {
				return $cos_array;
			}
			$prov_system_id = $this->get_first_member_provisioning_system_id ( $connection, $group_details->group_id );

			$domainProv = new models\external\prov\Domain ();
			$response = $domainProv->getAllDomainCos ( $connection, $group_details, $prov_system_id );
			if (is_array ( $response [ProvisioningConstant::A2_RESPONSE] )) {
				foreach ( $response [ProvisioningConstant::A2_RESPONSE] as $details ) {
					$cos_array [] = $details ['name'];
				}
			}
			return $cos_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_details->group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting Voice COS failed!", $e );
			}
			throw $e;
		}
	}

	// method to get MEP profile list
	public function get_mep_profile_list($connection, $group_details) {
        if (!MEP_AVILABLE_IN_SOLUTION){
            return array();
        }
		try {
			$profile_array = array ();
			if (ProvUtility::isDomainStatusConfiguredStandalone ( $group_details->top_level_domain_status )) {
				return $profile_array;
			}
			$prov_system_id = $this->get_first_member_provisioning_system_id ( $connection, $group_details->group_id );

			$individualProv = new models\external\prov\Individual ();
			return $individualProv->getMEPGroupProfile ( $connection, $group_details, $prov_system_id );
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_details->group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting MEP Profile list failed!", $e );
			}
			throw $e;
		}
	}

	// Method to get PSTN for provisioning
	public function get_pstn_for_provisioning($parameter_array) {
		$response_array = array ();
		$connection = DbConnector::getConnection ();
		$group_id = CommonHelper::getContextValue ( 'group_id' );

		try {
			$filter_array ['limit'] = UtilityMethods::getPageLimit ( $parameter_array, PageSizeConstant::PROVISION_PSTN_DEFAULT_PAGE_SIZE );
			$filter_array ['offset'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_OFFSET, 0 );
			$filter_array ['sort_by'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_BY, NULL );
			$filter_array ['sort_order'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_ORDER, CommonConstant::SORTING_ORDER_ASCENDING );
			$filter_array ['search_text'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SEARCH_KEYWORD, NULL );
			if (isset ( $parameter_array ['selected_only'] )) {
				$filter_array ['selected_only'] = $parameter_array ['selected_only'];
				$filter_array ['selected_list'] = $parameter_array ['selected_list'];
			}
			$include_subscriber = "";
			if (array_key_exists ( "subscriber_user_id", $parameter_array )) {
				$subscriber_details = SubscriberDao::get_subscriber_details_by_user_id ( $connection, $parameter_array ['subscriber_user_id'], $group_id, 'subscriber_id' );
				if ($subscriber_details) {
					$include_subscriber = $subscriber_details ['subscriber_id'];
				}
			}
			$filter_array ['include_subscriber'] = $include_subscriber;
			$filter_array ['site_id'] = $parameter_array['site_id'];
			$pstn_response = PstndidDao::get_individual_provision_pstndid_list ( $connection, $group_id, $filter_array );

			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $pstn_response ['pstndid_list'];
			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = $pstn_response ["count"];
			$response_array [CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $filter_array ['offset'];
			$response_array [CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = PageSizeConstant::PROVISION_PSTN_DEFAULT_PAGE_SIZE;
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting PSTN list for provision failed!", $e );
			}
			throw $e;
		}
	}

	// Method to get terminal for provisioning
	public function get_terminal_for_provisioning($parameter_array) {
		$response_array = array ();
		$connection = DbConnector::getConnection ();
		$group_id = CommonHelper::getContextValue ( 'group_id' );
		try {
			$filter_array ['limit'] = UtilityMethods::getPageLimit ( $parameter_array, PageSizeConstant::PROVISION_DEVICE_DEFAULT_PAGE_SIZE );
			$filter_array ['offset'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_OFFSET, 0 );
			$filter_array ['sort_by'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_BY, NULL );
			$filter_array ['sort_order'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_ORDER, CommonConstant::SORTING_ORDER_ASCENDING );
			$filter_array ['search_text'] = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SEARCH_KEYWORD, NULL );

			if (isset ( $parameter_array ['selected_only'] ) && $parameter_array ['selected_only'] == "true") {
				$filter_array ['selected_only'] = $parameter_array ['selected_only'];
				$filter_array ['selected_list'] = $parameter_array ['selected_list'];
			}
			$include_subscriber = "";
			$include_unistim = FALSE;

			if (array_key_exists ( "subscriber_user_id", $parameter_array )) {
				$subscriber_details = SubscriberDao::get_subscriber_details_by_user_id ( $connection, $parameter_array ['subscriber_user_id'], $group_id, 'subscriber_id' );
				if ($subscriber_details) {
					$include_subscriber = $subscriber_details ['subscriber_id'];
				}
			}
			$filter_array ['include_subscriber'] = $include_subscriber;

			if (array_key_exists ( "site_identifier", $parameter_array )) {
				$site_details = SiteDao::get_site_service_detail ( $connection, $group_id, $parameter_array ['site_identifier'] );
				if (UtilityMethods::isEqual ( $site_details ['unistim_device'], CommonConstant::ENABLE )) {
					$include_unistim = TRUE;
				}
			}
			$filter_array ['include_unistim'] = $include_unistim;

			$terminal_response = TerminalsDao::get_terminal_list_for_provisioning ( $connection, $group_id, $filter_array );

			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $terminal_response ['terminal_list'];
			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = $terminal_response ["count"];
			$response_array [CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $filter_array ['offset'];
			$response_array [CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = PageSizeConstant::PROVISION_DEVICE_DEFAULT_PAGE_SIZE;
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$inputs = array (
						"GROUP_ID" => $group_id
				);
				$this->_error ( $this->_getVarDump ( $inputs ) . "Getting Terminal list for provision failed!", $e );
			}
			throw $e;
		}
	}

	// method to get the subscriber paurl service
	public function get_paurl_and_lagacy_url($group_details) {
		$response_array = array ();
		$response_array ["pa_url"] = "";
		$response_array ["legacy_pa_url"] = "";
		$connection = DbConnector::getConnection ();

		$fetch_dns_array = array (
				BrandingDNSConstant::DNS_NAME_PERSONAL_AGENT,
				BrandingDNSConstant::DNS_NAME_LEGACY_AGENT
		);
		$dns_detail_array = BrandingDNSDao::get_dns_detail_by_names ( $connection, $group_details->group_id, $fetch_dns_array );

		if (UtilityMethods::isNotEmpty ( $dns_detail_array )) {
			foreach ( $dns_detail_array as $dns_detail ) {
				if (UtilityMethods::isEqual ( $dns_detail ["dns_name"], BrandingDNSConstant::DNS_NAME_PERSONAL_AGENT, false )) {
					$response_array ["pa_url"] = trim($dns_detail ['fqdn'], '/') . '/' . ltrim($dns_detail ['path'], '/');
				} else {
					$response_array ["legacy_pa_url"] = trim($dns_detail ['fqdn'], '/') . '/' . ltrim($dns_detail ['path'], '/');
				}
			}
		}
		return $response_array;
	}

	// method to get the subscriber paurl service
	public function get_subscriber_paurl_service($user_id, $group_details) {
		$response_array = array ();
		$connection = DbConnector::getConnection ();

		$db_subscriber_details = SubscriberDao::get_subscribers_details ( $connection, $group_details->group_id, $user_id );
		if ($db_subscriber_details === false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Invalid User Id provided..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::RESOURCE_NOT_EXISTS;
			return $response_array;
		}

		$fetch_dns_array = array (
				BrandingDNSConstant::DNS_NAME_PERSONAL_AGENT
		);
		$dns_detail = BrandingDNSDao::get_dns_detail_by_names ( $connection, $group_details->group_id, $fetch_dns_array );

		$auth_token = UtilityMethods::getUserAuthToken ( $user_id, $group_details->group_identifier );
		// Update the hash key
		$parameter_details = array (
				"pa_auth_token" => $auth_token . ProvisioningConstant::PA_AUTO_LOGIN_TIMESTAMP_CONCAT_SYMBOL . time ()
		);
		$primary_key_details = array (
				"user_id" => $user_id,
				"group_id" => $group_details->group_id
		);
		Dao::updateBasedOnGivenKey ( $connection, "subscriber", $primary_key_details, $parameter_details );

		$response_array = array (
				"hashValue" => $auth_token
		);
		$response_array ["pa_url"] = trim($dns_detail ['fqdn'], '/') . '/' . ltrim($dns_detail ['path'], '/');
		return $response_array;
	}

	// method to get the subscriber paurl service
	public function get_subscriber_old_paurl_service($user_id, $group_details) {
		$response_array = array ();
		$connection = DbConnector::getConnection ();

		$db_subscriber_details = SubscriberDao::get_subscribers_details ( $connection, $group_details->group_id, $user_id );
		if ($db_subscriber_details === false) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Invalid User Id provided..." . $user_id );
			}
			$response_array ["ERROR_CODE"] = ApiResponseConstant::RESOURCE_NOT_EXISTS;
			return $response_array;
		}
		$fetch_dns_array = array (
				BrandingDNSConstant::DNS_NAME_LEGACY_AGENT
		);
		$dns_detail = BrandingDNSDao::get_dns_detail_by_names ( $connection, $group_details->group_id, $fetch_dns_array );

		$individualProv = new models\external\prov\Individual ();
		$response_array = $individualProv->getPAurl ( $connection, $group_details, $db_subscriber_details );
		$response_array ["legacy_pa_url"] = trim($dns_detail ['fqdn'], '/') . '/' . ltrim($dns_detail ['path'], '/');
		return $response_array;
	}

    /**
     * method to generate a voicemail account with the sequence number
     *
     * @param object connection
     * @return string
     */
    private function _generate_voicemail_account($connection)
    {
        $tempVmAccountValue = Dao::get_sequence_number(CommonConstant::VOICEMAIL_ACCOUNT_SEQUENCE_KEY, 1);
        if (UtilityMethods::isEqual(strlen($tempVmAccountValue), VOICE_MAIL_ACCOUNT_MAX_LENGTH)) {
            return $tempVmAccountValue;
        } else {
            $voicemailAccount = VOICE_MAIL_ACCOUNT_PREFIX . str_pad($tempVmAccountValue, 11, 0, STR_PAD_LEFT);
            return $voicemailAccount;
        }
    }

	// end of method _generate_voicemail_account()
	// send notification for call recording
	private function _send_call_recording_notifications($state, $group_details, $subscriber_details, $comments) {
		$content = '';
		$content .= "<br/>";
		$content .= "<p> User id 				:  " . $subscriber_details ['user_id'];
		$content .= "<p> first name		:  " . $subscriber_details ['first_name'];
		$content .= "<p> last name 		:  " . $subscriber_details ['last_name'];
		if ($this->_is_field_not_empty ( $subscriber_details, "voip_numbers" ) && count ( $subscriber_details ['voip_numbers'] ) > 0) {
			$content .= "<p> Primary pstn	:  " . $subscriber_details ['voip_numbers'] [0];
			$content .= "<p> All pstn			:  " . implode ( "|", $subscriber_details ['voip_numbers'] );
		} else {
			$content .= "<p> Primary pstn	:  ";
			$content .= "<p> All pstn			:  ";
		}
		$content .= "<p> Region				:  " . SITE_REGION_NAME;
		$content .= "<p> Group Name	:  " . $group_details->business_name;
		$content .= "<p> Comments	:  " . $comments;
		$content .= "<br/>";

		$message = <<<CONTENT
               <p><b>$state Request</b></p>
               <p> $content</p>
CONTENT;

		$to = explode ( ',', CALL_RECORDING_TO_EMAILID );
		if ($this->_isDebugEnabled ()) {
			$this->_debug ( "Call recording message content is:" . $message );
		}
		return UtilityMethods::sendEmail ( $to, CALL_RECORDING_EMAIL_SUBJECT, $message, CALL_RECORDING_FROM_EMAILID );
	}

	// method to get subscriber type
	public function get_subscriber_type($subscriber_user_id, $group_id) {
		try {
			$connection = DbConnector::getConnection ();
			$subscriber_details = SubscriberDao::get_subscriber_details_by_user_id ( $connection, $subscriber_user_id, $group_id, "subscriber_type" );
			return $subscriber_details ["subscriber_type"];
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Facade -> Exception occurred on get_subscriber_type!", $e );
			}
			throw $e;
		}
	}

	// method to check where group has mobile extension enabled
	public function is_mobile_extension_visible() {
		try {
			$response_array = array ();
			$connection = DbConnector::getConnection ();
			$group_details = GroupA2DomainConfigDao::get_group_a2_domain_config ( $connection, CommonHelper::getContextValue ( "group_id" ), "is_mobile_extension_enabled" );
			$response_array ["is_mobile_extension_visible"] = ( bool ) $group_details ["is_mobile_extension_enabled"];
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Facade -> Exception occurred on is_mobile_extension_visible!", $e );
			}
			throw $e;
		}
	}

	// method to get subscriber details by user id - For Client purpose
	public function get_subscriber_details_by_user_id($subscriber_user_id, $group_id, $fields = '*') {
		try {
			$connection = DbConnector::getConnection ();
			$subscriber_details = SubscriberDao::get_subscriber_details_by_user_id ( $connection, $subscriber_user_id, $group_id, $fields );
			return $subscriber_details;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Facade -> Exception occurred on get_subscriber_details_by_user_id!", $e );
			}
			throw $e;
		}
	}

	//Method get device registration status
	public function get_device_registration_status_by_subscriber($subscriber_user_id, $parameter_array) {
		try {
			$dashboard_degistration = new DashboardRegistrationFacade;
			$response = $dashboard_degistration->get_device_registration_status_by_subscriber($subscriber_user_id);
			//
			$response_array = array();
			global $search_text;
			$search_text=UtilityMethods::getValueFromArray($parameter_array,CommonConstant::QUERY_PARAM_SEARCH_KEYWORD,"");
			$limit = UtilityMethods::getPageLimit($parameter_array, PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE);
			$offset = UtilityMethods::getValueFromArray($parameter_array,CommonConstant::QUERY_PARAM_OFFSET,0);
			$order_by=UtilityMethods::getValueFromArray($parameter_array,CommonConstant::QUERY_PARAM_SORT_BY,'');
			$order_type=UtilityMethods::getValueFromArray($parameter_array,CommonConstant::QUERY_PARAM_SORT_ORDER,CommonConstant::SORTING_ORDER_ASCENDING);
			// if search_text filter result.
            if (isset($response['unmanaged_devices']) && (isset($search_text) || UtilityMethods::isClient())) {
				$response['unmanaged_devices'] = array_filter($response['unmanaged_devices'], function($value){
					global $search_text;
					return (preg_match ("*" . strtolower ($search_text) . "*", strtolower ($value ["mac"])) || preg_match ("*" . strtolower ($search_text) . "*", strtolower ($value ["user_agent"])));
				});
			}
			// perform reordering of columns.
			if(isset($order_by) && UtilityMethods::isNotEmpty($order_by)){
				if(UtilityMethods::isNotEmpty($order_type)){
					if(UtilityMethods::isEqual($order_type, CommonConstant::SORTING_ORDER_ASCENDING, true)){
						$sort_type = SORT_ASC;
					}elseif(UtilityMethods::isEqual($order_type, CommonConstant::SORTING_ORDER_DESCENDING, true)){
						$sort_type = SORT_DESC;
					}
                    $response['unmanaged_devices'] = UtilityMethods::array_sort($response['unmanaged_devices'] ?? null, $order_by, $sort_type);
				}
			}
			// get result from offset.
			// limit count of results.
			$total_umdevices = count($response['unmanaged_devices']);
			$response_array['managed_devices'] = $response['managed_devices'];
			$response['unmanaged_devices'] = array_slice($response['unmanaged_devices'], $offset, $limit);
			$response_array['unmanaged_devices'][CommonConstant::API_CUSTOM_PARAM_RESOURCE_LIST] = $response['unmanaged_devices'];
			$response_array['unmanaged_devices'][CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = $total_umdevices;
			$response_array['unmanaged_devices'][CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $offset;
			$response_array['unmanaged_devices'][CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = PageSizeConstant::SUBSCRIBER_DEFAULT_PAGE_SIZE;
			return $response_array;
		} catch ( Exception $e ) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Subscriber Facade -> Exception occurred on get_subscriber_details_by_user_id!", $e );
			}
			throw $e;
		}
	}

	// Method to get all site details
	public function get_site_list($type) {
		try {
			$response_array = array ();
			$connection = DbConnector::getConnection ();
			$group_id = CommonHelper::getContextValue ( "group_id" );

			$site_response = SiteDao::get_site_list_for_subscribers ( $connection, $group_id, $type );

			return $site_response;
		} catch ( Exception $e ) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Site list fetch failed!!", $e );
			}
			throw $e;
		}
	}
	//Method to get application server list
	public function get_application_server_list() {
	    try {
	        $response_array = array ();
	        $connection = DbConnector::getConnection ();
	        $group_id = CommonHelper::getContextValue ( "group_id" );
	        //$parent_group_id = GroupDao::get_parent_group_details($connection, $group_id);
	        $server_list_response['application_server_list'] = ApplicationServerDao::get_cluster_name_by_customer( $connection, $group_id );

	        return $server_list_response;
	    } catch ( Exception $e ) {
	        if ($this->_isErrorEnabled ()) {
	            $this->_error ( "Application Server list fetch failed!!", $e );
	        }
	        throw $e;
	    }
	}
	//Method to get associated device pools
	public function get_device_pools_list() {
	    try {
	        $response_array = array ();
	        $connection = DbConnector::getConnection ();
	        $group_id = CommonHelper::getContextValue ( "group_id" );
	        $parent_group_id = GroupDao::get_parent_group_details($connection, $group_id);
	        $pool_list_response= ApplicationServerDao::get_device_pool_list_for_subscriber( $connection, $group_id, $parent_group_id['group_id'] );

	         return $pool_list_response;
	    } catch ( Exception $e ) {
	        if ($this->_isErrorEnabled ()) {
	            $this->_error ( "Device Pools list fetch failed!!", $e );
	        }
	        throw $e;
	    }
	}

	// Method to get given site details
	public function get_site_service_details_for_prov($site_identifier) {
		try {
			$connection = DbConnector::getConnection ();
			$group_id = CommonHelper::getContextValue ( "group_id" );
			$site_service_details = SiteDao::get_site_service_detail_for_client ( $connection, $group_id, $site_identifier );
            $site_service_details['is_eup_advanced_enabled'] = (SiteDao::get_default_allow_eup_enabling ($connection, $site_identifier, $group_id)['is_eup_advanced_enabled'] == 1 ? 'enabled' : 'disabled');
			if (UtilityMethods::isEmpty ( $site_service_details )) {
				return $this->_build_error_message ( ApiResponseConstant::SITE_IDENTIFIER_NOT_EXIST, "" );
			}
			return $site_service_details;
		} catch ( Exception $e ) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Site service details fetch failed!!", $e );
			}
			throw $e;
		}
	}

	private function _get_vm_pin_on_a2($connection, $subscriber_details, $group_details)
	{
		$vm_pin = NULL;
		if (ProvUtility::isVoicemailServiceHosted($subscriber_details["voicemail_service"])) {
			$individualProv = new models\external\prov\Individual();
			$find_account_response = $individualProv->findVoicemail($connection, $group_details, $subscriber_details);
			if (!is_array($find_account_response)) {
				if ($this->_isErrorEnabled()) {
					$this->_error("Subscriber facade -> _get_vm_pin_on_a2 (FindAccountRequest1) failed for subscriber " . $subscriber_details["user_id"]);
				}
				return;
			}

			if (UtilityMethods::isEqual($group_details->voice_mail_device_type, ProvisioningConstant::PROVISION_DEVICE_TYPE_IMM)) {
				if (is_array($find_account_response) && isset($find_account_response["account"]) && count($find_account_response["account"]) > 0) {
					$accountCollection = $find_account_response["account"];
					if (isset($accountCollection["serviceSettingCollection"]) && is_array($accountCollection["serviceSettingCollection"]) && count($accountCollection["serviceSettingCollection"]) > 0) {
						$serviceSettingCollection = $accountCollection["serviceSettingCollection"];
						if (isset($serviceSettingCollection["serviceSetting"]) && is_array($serviceSettingCollection["serviceSetting"]) && count($serviceSettingCollection["serviceSetting"]) > 0) {
							$serviceSetting = $serviceSettingCollection["serviceSetting"];
							foreach ($serviceSetting as $serviceVal) {
								// get PIN
								if (array_key_exists('type', $serviceVal) && UtilityMethods::isEqual($serviceVal['type'], ProvisioningConstant::FIND_ACCOUNT_IMM_VM_PIN_TYPE)) {
									if (UtilityMethods::isNotEmpty($serviceVal['value'])) {
										$vm_pin = $serviceVal['value'];
									}
								}
							}
						}
					}
				}
			} else if (UtilityMethods::isEqual($group_details->voice_mail_device_type, ProvisioningConstant::PROVISION_DEVICE_TYPE_UREACH)) {
				if (is_array($find_account_response) && isset($find_account_response["Offer"]) && count($find_account_response["Offer"]) > 0) {
					$offer_array = $find_account_response["Offer"];
					if (isset($offer_array) && is_array($offer_array) && count($offer_array) > 0) {
						if (!array_key_exists("0", $offer_array)) {
							$param_array = $offer_array["Params"];
						} else {
							$param_array = $offer_array[0]["Params"];
						}
					}
					if (is_array($param_array) && isset($param_array) && count($param_array) > 0) {
						if (is_array($param_array) && isset($param_array["Number"]) && count($param_array["Number"]) > 0) {
							if (!array_key_exists("0", $param_array["Number"])) {
								if (array_key_exists('PIN', $param_array["Number"])) {
									if (UtilityMethods::isNotEmpty($param_array["Number"]['PIN'])) {
										$vm_pin = $param_array["Number"]['PIN'];
									}
								}
							} else {
								if (array_key_exists('PIN', $param_array["Number"][0])) {
									if (UtilityMethods::isNotEmpty($param_array["Number"][0]['PIN'])) {
										$vm_pin = $param_array["Number"][0]['PIN'];
									}
								}
							}
						}
					}
				}
			}
		}
		return $vm_pin;
	}

	// get subscriber phone numbers list for root
	public function get_subscriber_phonenumbers_list($parameter_array) {
		try {
			$response_array = array ();
			$search_text = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SEARCH_KEYWORD, "" );
			$limit = UtilityMethods::getPageLimit ( $parameter_array, PageSizeConstant::SUBSCRIBER_PHONE_NUMBERS_LIST_DEFAULT_PAGE_SIZE );
			$offset = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_OFFSET, 0 );
			$order_by = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_BY, 'user_id' );
			$order_type = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_SORT_ORDER, CommonConstant::SORTING_ORDER_ASCENDING );
			$fields = UtilityMethods::getValueFromArray ( $parameter_array, CommonConstant::QUERY_PARAM_FIELDS, '*' );
			$connection = DbConnector::getConnection ();

            if (SessionUtility::isContextGroupTypePartner()) {
                $total_count = SubscriberDao::getSubscriberPhoneNumberListCountForPartner($connection, $offset, $limit, $search_text, $order_by, $order_type, $fields );
                $subscriberList = SubscriberDao::getSubscriberPhoneNumberListForPartner($connection, $offset, $limit, $search_text, $order_by, $order_type, $fields );
            } else {
                $total_count = SubscriberDao::get_subscriber_phonenumber_list_count ( $connection, $offset, $limit, $search_text, $order_by, $order_type, $fields );
                $subscriberList = SubscriberDao::get_subscriber_phonenumber_list ( $connection, $offset, $limit, $search_text, $order_by, $order_type, $fields );
            }

            $response_array ["subscriberlist"] = $subscriberList;
            $response_array ["count"] = $total_count;
			$response_array ["limit"] = $limit;
			$response_array [CommonConstant::API_CUSTOM_PARAM_RESOURCE_COUNT] = $total_count;
			$response_array [CommonConstant::API_CUSTOM_PARAM_CURRENT_OFFSET] = $offset;
			$response_array [CommonConstant::API_CUSTOM_PARAM_MAX_PAGE_SIZE] = $limit;
			return $response_array;
		} catch ( Exception $e ) {
			// catching Error
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Getting Subscriber list for ROOT failed!", $e );
			}
			throw $e;
		}
	}

	// end of method get_subscriber_list()
	// method to get smart office group id for smart office bundles
	private function _get_smart_office_group_id($group_details) {
		if (UtilityMethods::isSMB ( $group_details->group_type )) {
			return $group_details->parent_group_id;
		} else {
			return $group_details->group_id;
		}
	}

	// method to get supplier incompatible details
	public function supplier_incompatible_details() {
		$ProductFacade = new ProductFacade ();
		$response_array ['incompatible_details'] = $ProductFacade->supplier_incompatible_details ();

		$connection = DbConnector::getConnection ();
		$default_inventory = OrderDao::get_default_inventory_order_items ( $connection, CommonHelper::getContextValue ( "group_id" ) );
		if (UtilityMethods::isEmpty ( $default_inventory )) {
			// Do nothing
			return $response_array;
		}

		$modified_sku_details = array ();
		$default_inventory = UtilityMethods::array_column ( $default_inventory, "product_id", "sku" );
		foreach ( $response_array ['incompatible_details'] as $sku => &$incompatible_details ) {
			foreach ( $default_inventory as $default_sku => $product_id ) {
				if (array_search ( $default_sku, $incompatible_details ) !== FALSE) {
					$incompatible_details [] = CommonConstant::DEFAULT_INVENTORY_SKU_PREFIX . dechex ( $product_id );
				}
			}

			if (! isset ( $modified_sku_details [$sku] )) {
				if (isset ( $default_inventory [$sku] )) {
					unset ( $response_array ['incompatible_details'] [$sku] );
					$response_array ['incompatible_details'] [CommonConstant::DEFAULT_INVENTORY_SKU_PREFIX . dechex ( $default_inventory [$sku] )] = $incompatible_details;
					$response_array ['incompatible_details'] [$sku] = $incompatible_details;
				}
				$modified_sku_details [$sku] = $sku;
			}
		}

		return $response_array;
	}
	public function cleanup_collab_access_code() {
		$connection = DbConnector::getConnection ();
		SubscriberDao::cleanup_collab_access_code ( $connection, COLLAB_ACCESS_CODE_RETENTION_AGE );
	}
	public function send_trial_expiry_notifications($connection, $group_id, $subscriber_id) {
		$notification_subject = "Trial Has Expired";
		$notification_msg = "Your trial has expired";
		$notification_type = NotificationConstant::NOTIFICATION_TYPE_ACCOUNT;
		$notification_priority = NotificationConstant::NOTIFICATION_PRIORITY_HIGH;

		if (! is_array ( $group_id )) {
			$fromEmail = $this->get_notification_emailid ( $connection, $group_id );
		} else {
			$fromEmail = $this->get_notification_emailid ( $connection, CommonHelper::getContextValue ( 'group_id' ) );
			$group_id = implode ( ",", $group_id );
		}

		$template_content = file_get_contents ( EMAIL_TEMPLATE_PATH . EmailTemplateConstant::TRIAL_EXPIRED );

		$find = array (
				'/NAME/',
				'/SUBSCRIBERID/',
				'/TRIALDATE/'
		);

		$name = SubscriberDao::get_name ( $connection, $subscriber_id );
		$sub_id = $subscriber_id;
		$trial_date = SubscriberDao::get_trial_activation_date ( $connection, $subscriber_id );

		$replace = array (
				$name ['first_name'],
				$sub_id,
				$trial_date ['trial_activation']
		);

		$out_email_message = preg_replace ( $find, $replace, $template_content );
		$notification_msg = $out_email_message;
		$subscriber_email = SubscriberDao::get_subscriber_email ( $connection, $subscriber_id );

		if (! empty ( $subscriber_email ['email_address'] )) {
			$email_response = UtilityMethods::sendEmail ( $subscriber_email, $notification_subject, $out_email_message, $fromEmail );
			if (UtilityMethods::isEqual ( $email_response, "Email Sending Failed!" )) {
				$is_success = FALSE;
			}
		}
		$user_language = strtolower(CommonHelper::getParam(CommonConstant::USER_LANGUAGE));
		$email_template_url = EmailTemplateConstant::ORDER_STATUS_ACCEPTED;
		if($user_language == 'fr' || $user_language == 'french'){
			$email_template_url = EmailTemplateConstant::ORDER_STATUS_ACCEPTED_FR;
		}

		self::send_notification ( $connection, $group_id, PermissionConstant::OPERATIONS_PERMISSION, $notification_subject, $notification_msg, $notification_type, $notification_priority, $email_template_url );
	}
	public function expire_trials() {
		$connection = DbConnector::getConnection ();

		$subscribers_with_expired_trials = SubscriberDao::get_expired_trial_subscribers ( $connection );

		$seen_group_id = array ();

		foreach ( $subscribers_with_expired_trials as &$subscriber_id ) {
			$expiry_details = SubscriberDao::get_subscriber_expiry_details ( $connection, $subscriber_id );

			$expiry_action = $expiry_details ['trial_expiry_action'];
			$group_id = $expiry_details ['group_id'];

			// if (!isset($seen_group_id[$group_id])) {

			// /QQQQ NOTIFY THE SUBSCRIBER
			self::send_trial_expiry_notifications ( $connection, $group_id, $subscriber_id );
			// $seen_group_id[$group_id] = 1;
			// }

			if ($expiry_action == 'NOTIFY_REMOVE') {

				SubscriberDao::update_default_status_inactive ( $connection, $subscriber_id );
				// SubscriberDao::delete_subscriber($connection, $subscriber_id, $group_id);
				$subscriber_user_id = $expiry_details ['user_id'];
				$group_details = GroupDao::get_group_details_for_update ( $connection, $group_id );
				$this->delete_subscriber_details ( $subscriber_user_id, $group_details );
			}

			SubscriberDao::update_default_status_inactive ( $connection, $subscriber_id );
		}
	}

	public function get_default_client_type($site_identifier) {
		try {
			$response_array = array ();
			$group_id = CommonHelper::getContextValue ( "group_id" );
			$connection = DbConnector::getConnection ();
			$default_client_id = SiteDao::get_default_client_id ( $connection, $site_identifier,$group_id) ['client_type_id'];
			$response_array ['default_client_type'] = ClientConfigurationDao::get_catalog_client_type_by_id ( $connection, $default_client_id ) ['client_type'];

			return $response_array;
		} catch ( Exception $e ) {
			if ($this->_isErrorEnabled ()) {
				$this->_error ( "Unable to get client list:", $e );
			}
			throw $e;
		}
	}
	public function get_default_allow_eup_config($site_identifier) {
	    try {
	        $response_array = array ();
	        $group_id = CommonHelper::getContextValue ( "group_id" );
	        $connection = DbConnector::getConnection ();
	        $response_array ['default_phonebutton_enabled'] = SiteDao::get_default_allow_eup_enabling($connection, $site_identifier,$group_id)['is_phonebutton_enabled'];
	        return $response_array;
	    } catch ( Exception $e ) {
	        if ($this->_isErrorEnabled ()) {
	            $this->_error ( "Unable to get client list:", $e );
	        }
	        throw $e;
	    }
	}

	/**
	 *
	 * @param unknown $site_details
	 * @return string
	 */
	public function get_access_ip( $connection,$site_identifier,$groupId) {
		$pbx_info = SiteDao::get_pbx_info($connection, $site_identifier, $groupId);
		if($pbx_info["has_call_recording"]){
			if(strcmp($pbx_info["pbx_type"],"static_sbc")==0){
				return ACCESS_SBC_CR_CONNECT_IP;
			}else if(strcmp($pbx_info["pbx_type"],"static_pbx")==0){
				return ACCESS_DIRECT_CR_CONNECT_IP;
			}else{
				return null;
			}
		}else {
			if(strcmp($pbx_info["pbx_type"],"static_sbc")==0){
				return ACCESS_SBC_CONNECT_IP;
			}else if(strcmp($pbx_info["pbx_type"],"static_pbx")==0){
				return ACCESS_DIRECT_CONNECT_IP;
			}else{
				return null;
			}
		}
	}


	/**
	 *
	 * @param unknown $numbers
	 * @param unknown $ips
	 */
	public function get_extended_userIds($numbers, $ips){
		$combinedArray = array();
		foreach($ips as $ip){
			foreach($numbers as $number ){
				array_push($combinedArray,$number."@".$ip);
			}
		}
		return $combinedArray;;
	}


	public function has_pbx_menu_bundle($connection,$service_set_value) {
		$menus = ProductDao::getSubscriberMenuByServiceSet ( $connection, $service_set_value );
		$menu = explode ( "|", $menus );
		foreach ($menu as $m ) {
			if (UtilityMethods::is_pbx_menu_bundle( $m )) {
				return true;
			}
		}
		return false;
	}

	//function get_required_purchase_product_ids_for_mida_from_product_id_array($connection, $product_id_array, $group_id, &$ref_ss_array) {
    function handle_new_mida_purchase($connection, $product_id_array, $group_details, $subscriber_details) {
        $this->_debug("Subscriber Facade -> handle_new_mida_purchase is started");
        $ss_array = array();
        $required_purchase_ids = array();
        foreach ($product_id_array as $prod_id) {
            $ss = ProductDao::getServiceSetIdsByProcuctId($connection, $prod_id);
            foreach ($ss as $s) {
                $ss_array[] = ServiceSetDao::get_service_set_name_by_service_set_id($connection, $s);
            }
            unset($s);
            $ss = implode('|', $ss_array);
            if (UtilityMethods::is_mida_bundle($ss)) {
                $required_purchase_ids[] = ProductDao::get_activation_product_details($connection, $prod_id, $group_details->group_id, "product_id");
            }
        }
        unset($prod_id);

        // order any required products if they exist
        if (!empty ($required_purchase_ids)) {
            $new_order = array();
            foreach ($required_purchase_ids as $purchase) {
                if (!empty ($purchase)) {
                    $new_order [] = array(
                        "product_id" => $purchase ["product_id"],
                        "quantity" => 1
                    );
                }
            }
            unset ($purchase);
            $orderfacade = new OrderFacade ();
            $this->_debug("Subscriber Facade -> handle_new_mida_purchase -> insert_automatic_order is started");
            $orderfacade->insert_automatic_order($connection, $group_details->group_id, $new_order, array());
            $this->_debug("Subscriber Facade -> handle_new_mida_purchase -> insert_automatic_order is ended");
        }

        //update subscriber presence settings to enable Mida features that rely on presence
        $pa = new Pa();
        $presence_params = array();
        /*$sub_info = array();
        $sub_info['prov_system_id'] = $this->get_first_member_provisioning_system_id($connection, $group_details->group_id);
        $sub_info['user_id'] = $subscriber_details['user_id'];*/
        $presence_params['on_the_phone_presence'] = CommonConstant::ENABLE;
        $presence_params['report_when_inactive'] = CommonConstant::ENABLE;
        $presence_params['inactivity_timer'] = 30;
        $pa->setUserProfilePresence($connection, $subscriber_details, $presence_params);
        $this->_debug("Subscriber Facade -> handle_new_mida_purchase is ended");
    }

    /**
     * @return Object the A2 response with a list of all emergency numbers
     */
    public function get_all_emergency_numbers() {
    return parent::get_all_emergency_numbers();
  }

    public function  get_subscribers_sync_status($subscriber_list){
    try {
        if (empty($subscriber_list))
            return array();
        $user_id_list = array();
        $sync_status_array = array();
        $terminalfacade = new TerminalsFacade();
        $params = array();
        foreach ($subscriber_list as $sub){
            array_push($sync_status_array,"");
            $sub['check_sync_status'] = "";
            array_push($params,$sub);
            array_push($user_id_list, $sub['full_user_id']);
        }
        $connection = DbConnector::getConnection ();
        $mac_address_list = TerminalsDao::get_mac_address_list_for_subscribers_by_users_ids($connection, $user_id_list);
        $gen_mac_list = GenericDeviceDao::get_generic_mac_address_list_for_subscribers_by_users_ids($connection, $user_id_list, "mac_address");
        $mac_address_list = array_merge($mac_address_list, $gen_mac_list);
        if (UtilityMethods::isNotEmpty($mac_address_list)) {
            $mac_address_list = array_column($mac_address_list, "mac_address");
            $terminalfacade->get_device_sync_status($mac_address_list);//function to check ZTP file
            $sync_status_list = SyncDeviceStatusDao::get_device_sync_status_with_subscriber_id($connection, $mac_address_list);// take sync status after check ZTP file
            foreach ($sync_status_list as $sync_status){
                $key = null;
                $key = array_search($sync_status['user_id'], $user_id_list);
                if ($key || $key === 0) { // FOUND or index == 0, not NOT FOUND
                    if 	($sync_status['status'] == 'Fail'){
                        $sync_status_array[$key] = 'Fail';
                        unset ($user_id_list[$key]);
                    }
                    elseif ($sync_status['status'] == 'Pending'){
                        $sync_status_array[$key] = 'Pending';
                    }
                    elseif ($sync_status['status'] == 'Scheduled'){
                        $sync_status_array[$key] = 'Scheduled';
                    }
                    elseif ($sync_status['status'] == 'Success'){
                        $time_new = strtotime($sync_status['end_time']);
                        $time_old = strtotime($sync_status_array[$key]);
                        if($time_new > $time_old){
                            $sync_status_array[$key] = strtotime($sync_status['end_time']);
                        }
                    }
                }
            }
            for ($i = 0; $i < count($subscriber_list);$i++){
                $params[$i]['check_sync_status']  = $sync_status_array[$i];
                //Adding scheduled_time if check_sync_status is scheduled (for tooltip)
                $key = array_search($params[$i]['full_user_id'], array_column($sync_status_list, 'user_id'));
                if($params[$i]['check_sync_status'] == 'Scheduled'){
                    $scheduled_time = strtotime($sync_status_list[$key]['sync_scheduled_time']);
                    $params[$i]['scheduled_time'] = $scheduled_time;
                }else if($params[$i]['check_sync_status'] == 'Fail'){
                    $currentUserLanguage = UtilityMethods::get_current_user_language();
                    $currentLoginUserLanguage = CommonConstant::LANGUAGE_ENGLISH_VALUE;
                    $dateFormat = 'Y-m-d H:i:s';
                    switch ($currentUserLanguage) {
                        case GroupConstant::LANGUAGE_PREFERENCE_FRENCH:
                            $currentLoginUserLanguage = CommonConstant::LANGUAGE_FRENCH_VALUE;
                            break;
                        default:
                            $currentLoginUserLanguage = CommonConstant::LANGUAGE_ENGLISH_VALUE;
                    }
                    $failure_message = '';
                    if (!empty($sync_status_list[$key]['sync_trigger_time'])) {
                        $formattedAttempt = UtilityMethods::format_date(
                            $sync_status_list[$key]['sync_trigger_time'],
                            $dateFormat
                        );
                        $failure_message .= UtilityMethods::get_message(
                            ApiResponseConstant::ATTEMPT_TIME,
                            $currentLoginUserLanguage
                        ) . ": \n" . $formattedAttempt . "\n";
                    }
                    $failure_message .= UtilityMethods::get_message(
                        ApiResponseConstant::LAST_SUCCESS_TIME,
                        $currentLoginUserLanguage
                    );
                    if (!empty($sync_status_list[$key]['last_success_time'])) {
                        $formattedDate = UtilityMethods::format_date(
                            $sync_status_list[$key]['last_success_time'],
                            $dateFormat
                        );
                        $failure_message .= ": \n" . $formattedDate . "\n";
                    } else {
                        $failure_message .= ': ' . UtilityMethods::get_message(
                            ApiResponseConstant::NONE_SUCCESS,
                            $currentLoginUserLanguage
                        );
                    }
                    $params[$i]['info'] = $failure_message;
                }
            }
        }
        $response_array['subscriberlist'] = $params;
        return $response_array;
    } catch ( Exception $e ) {
        // catching Error
        if ($this->_isErrorEnabled ()) {
            $this->_error ( "Getting get devices sync status  failed!", $e );
        }
        throw $e;
    }
  }

    /**
     * Add the call recording user to the call recording system.
     * There are types of subscribers.
     *
     * Regular subscriber: In this case add the subscriber's voip number, pstn did's and aliases as identities
     * against the subscribers user id.
     *
     * Sip Trunk subscriber: In addtion to what is done for the regular subscriber, add the subscriberid@end_point_ip as
     * an additional subscriber identifier.
     */
    private function _add_call_recording_user($connection, $service_set_value, $subscriber_details, &$call_executed_list)
    {

        if (
            isset($subscriber_details['callRecordingSettings']['organizationalGroupNames'])
            && UtilityMethods::isNotEmpty($subscriber_details['callRecordingSettings']['organizationalGroupNames'])
            && strlen($subscriber_details['callRecordingSettings']['organizationalGroupNames']) > 255
        ) {
            return [
                "ERROR_CODE" => ApiResponseConstant::ORGANIZATIONAL_GROUP_NAME_MAX_LENGTH
            ];
        }

        $orecxProv = new models\external\prov\Orecx();
        $group_details_as_array = GroupDao::get_group_details_for_update($connection, $subscriber_details['group_id'], false);
        $group_details = GroupDao::get_group_details_for_update($connection, $subscriber_details['group_id']);
        $subscriber_details['recordable'] = true;
        if (UtilityMethods::isLiveSupportCallRecordingServiceBundle($service_set_value)) {
            $subscriber_details["user_password"] = SITE_ORECX_PASSWORD;
        }

        //Added voip alias to login string
        if(UtilityMethods::isOrganization($group_details->group_type) && isset($subscriber_details["voip_alias"])) {
            $voIpAliases = explode(" ", $subscriber_details["voip_alias"]);
            foreach ($voIpAliases as $voIpAlias) {
                if(!empty($voIpAlias)) {
                    $subscriber_details["extended_userids"][] = $voIpAlias . "@" . $group_details->top_level_domain;
                }
            }
        }
        // Sip trunk subscriber
        if ($this->has_pbx_menu_bundle($connection, $service_set_value)) {
            $groupId = $group_details->group_id;
            $site_details = SiteDao::get_site_details($connection, $groupId, $subscriber_details["site_identifier"]);
            $accessIp = $this->get_access_ip($connection, $subscriber_details["site_identifier"], $groupId);
            $pbxIp = $site_details["sip_pbx_ip_address"];
            $accessIps = array(
                $accessIp,
                $pbxIp
            );
            $extendedUserIds = $this->get_extended_userIds($subscriber_details["voip_numbers"], $accessIps);
            $subscriber_details["extended_userids"][] = $extendedUserIds;
            $orecxProv->addUserToGroup($connection, $group_details_as_array, $subscriber_details);
            // Regular subscriber.
        } else {
            $orecxProv->addUserToGroup($connection, $group_details_as_array, $subscriber_details);
        }
        // Check to see if call recording response was set - Succesfully added the call recording subscriber at this point
        $user_id = $subscriber_details['user_id'];
        if (isset($subscriber_details['call_recording_xid'])) {
            $call_recording_id = $subscriber_details['call_recording_xid'];

            if ($this->_isDebugEnabled()) {
                $this->_debug(" Subscriber Facade -> _add_call_recording_user succeeded  for user " . $user_id . " call_recording_id " . $call_recording_id);
            }
            CallRecMemberDao::insert_mapping($connection, $user_id, $call_recording_id);
            $call_executed_list[] = "_add_call_recording_user => addUser";
            $this->_send_call_recording_notifications("Add", $group_details, $subscriber_details, "");
            // Save the orecx subscriber identifier to the system.
            try {
                if (UtilityMethods::isLiveSupportCallRecordingServiceBundle($service_set_value)) {
                    $this->_callRecordingRoleAssignment(
                        $connection,
                        $service_set_value,
                        $subscriber_details['call_recording_xid'],
                        $subscriber_details['prov_system_id']
                    );
                }
            } catch (Exception $e) {
                $this->_error('Subscriber Facade -> _add_call_recording_user failed  for user ' . $user_id . 'Role associate failed.', $e);
                $this->_error($e->getTraceAsString());
                $this->_check_translated_response([], ApiResponseConstant::CALL_RECORDING_ASSOCIATE_USER_TO_ROLE);
            }
        } else {
            if ($this->_isDebugEnabled()) {
                $this->_debug(" Subscriber Facade -> _add_call_recording_user failed  for user " . $user_id);
            }
            $this->_send_call_recording_notifications("Add", $group_details_as_array, $subscriber_details, "orecx=>addUser() failed.");
            $this->_check_translated_response([], ApiResponseConstant::SUBSCRIBER_ADD_CALL_RECORDING_USER_CALL_FAILED);
        }
        // Unset the internal variables
        unset($subscriber_details["extended_userids"]);

        if (UtilityMethods::isCallRecordingServiceBundleWithoutLS($service_set_value)) {
            if (
                isset($subscriber_details['callRecordingDetails']['organizationalGroupNames'])
                && UtilityMethods::isNotEmpty($subscriber_details['callRecordingDetails']['organizationalGroupNames'])
            ) {
                $subscriber_details['callRecordingSettings']['organizationalGroupIDs'] = [];
                $orecxGroupID = $orecxProv->getOrecxGroupID($connection, $subscriber_details['group_id']);
                $childOrganizationalGroups = $orecxProv->getChildOrganizationalGroups(
                    $connection,
                    $subscriber_details['prov_system_id'],
                    $orecxGroupID['orecx_group_id']
                );
                foreach ($subscriber_details['callRecordingDetails']['organizationalGroupNames']
                         as $organizationalGroupName) {
                    foreach ($childOrganizationalGroups['objects'] as $group) {
                        if (UtilityMethods::isEqual($group['groupName'], $organizationalGroupName)) {
                            array_push(
                                $subscriber_details['callRecordingSettings']['organizationalGroupIDs'],
                                $group['id']);
                        }
                    }
                }
				$subscriber_details['callRecordingSettings']['organizationalGroupNames'] = implode('|', $subscriber_details['callRecordingDetails']['organizationalGroupNames']);
            }
            $orecxProv->orecxGroupManagement(
                $connection,
                $subscriber_details,
                $group_details,
                CallRecordingConstant::SAVE
            );

            $role = isset($subscriber_details['callRecordingDetails']['securityGroup']) ?
                $subscriber_details['callRecordingDetails']['securityGroup'] :
                $subscriber_details['callRecordingSettings']['securityGroup'];
            if (empty($role) || UtilityMethods::isEqual($role, CallRecordingConstant::ROLE_ADMINSTRATORS)) {
                $roleID = CallRecordingConstant::USER_ROLE_ID;
            } else {
                $roleID = CallRecordingRoleDao::getRoleIDByName($connection, $role);
                if (empty($roleID)) {
                    $roleID = CallRecordingConstant::USER_ROLE_ID;
                }
            }

            $callRecordingRoleDetails = [
                'call_recording_user_id' => $subscriber_details['call_recording_xid'],
                'call_recording_role_id' => $roleID
            ];
            $orecxProv->associateUsersToRole(
                $connection,
                $subscriber_details['prov_system_id'],
                $callRecordingRoleDetails
            );
            CallRecordingRoleDao::setUserRole($connection, $subscriber_details['call_recording_xid'], $roleID);

            CallRecMemberDao::updateOrganizationalGroupNames(
                $connection,
                $subscriber_details['callRecordingSettings']['organizationalGroupNames'],
                $subscriber_details['call_recording_xid']
            );
		}
    }

    /**
     * Update call recording user
     */
    private function _update_call_recording_user(
        $connection,
        $service_set_value,
        $subscriber_details,
        &$call_executed_list,
        $oldServiceSetValue = ''
    )
    {

        if (
            isset($subscriber_details['callRecordingSettings']['organizationalGroupNames'])
            && UtilityMethods::isNotEmpty($subscriber_details['callRecordingSettings']['organizationalGroupNames'])
            && strlen($subscriber_details['callRecordingSettings']['organizationalGroupNames']) > 255
        ) {
            return [
                "ERROR_CODE" => ApiResponseConstant::ORGANIZATIONAL_GROUP_NAME_MAX_LENGTH
            ];
        }

        $orecxProv = new models\external\prov\Orecx();
        $group_details_as_array = GroupDao::get_group_details_for_update($connection, $subscriber_details['group_id'], false);
        $group_details = GroupDao::get_group_details_for_update($connection, $subscriber_details['group_id']);
        $subscriber_details["call_recording_xid"] = CallRecMemberDao::get_call_recording_xid($connection, $subscriber_details['user_id']);
        if (UtilityMethods::isLiveSupportCallRecordingServiceBundle($service_set_value)) {
            $subscriber_details["user_password"] = SITE_ORECX_PASSWORD;
        }
        if (UtilityMethods::isLiveSupportCallRecordingServiceBundle($service_set_value)) {
            $subscriber_details['disabled'] = isset($subscriber_details['service_access_status']) && strcmp(
                $subscriber_details['service_access_status'],
                ProvisioningConstant::SUBSCRIBER_SERVICE_ACCESS_STATUS_INACTIVE
            ) === 0;
        }
        //Added voip alias to login string
        if(UtilityMethods::isOrganization($group_details->group_type) && isset($subscriber_details["voip_alias"])) {
            $voIpAliases = explode(" ", $subscriber_details["voip_alias"]);
            foreach ($voIpAliases as $voIpAlias) {
                if(!empty($voIpAlias)) {
                    $subscriber_details["extended_userids"][] = $voIpAlias . "@" . $group_details->top_level_domain;
                }
            }
        }
        // Sip trunk subscriber
        if ($this->has_pbx_menu_bundle($connection, $service_set_value)) {
            $groupId = $group_details->group_id;
            $site_details = SiteDao::get_site_details($connection, $groupId, $subscriber_details["site_identifier"]);
            $accessIp = $this->get_access_ip($connection, $subscriber_details["site_identifier"], $groupId);
            $pbxIp = $site_details["sip_pbx_ip_address"];
            $accessIps = array(
                $accessIp,
                $pbxIp
            );
            $extendedUserIds = $this->get_extended_userIds($subscriber_details["voip_numbers"], $accessIps);
            $subscriber_details["extended_userids"][] = $extendedUserIds;
            $orecxProv->updateUser($connection, $group_details_as_array, $subscriber_details);
            // Regular subscriber.
        } else {
            $orecxProv->updateUser($connection, $group_details_as_array, $subscriber_details);
        }

        $user_id = $subscriber_details['user_id'];
        // Check to see if call recording response was set - Succesfully added the call recording subscriber at this point
        if (isset($subscriber_details['call_recording_xid'])) {
            $call_recording_id = $subscriber_details['call_recording_xid'];
            if ($this->_isDebugEnabled()) {
                $this->_debug(" Subscriber Facade -> _update_call_recording_user succeeded  for user " . $user_id . " call_recording_id " . $call_recording_id);
            }
            $call_executed_list[] = "_update_call_recording_user => updateUser";
            $this->_send_call_recording_notifications("Update", $group_details, $subscriber_details, "");
            // Save the orecx subscriber identifier to the system.

            if ($this->_calculateAssociationRules($service_set_value, $oldServiceSetValue)){
                try {
                    $this->_callRecordingRoleAssignment(
                        $connection,
                        $service_set_value,
                        $subscriber_details['call_recording_xid'],
                        $subscriber_details['prov_system_id']
                    );
                } catch(Exception $e) {
                    $this->_error('Subscriber Facade -> _update_call_recording_user failed  for user ' . $user_id . 'Role associate failed.');
                    $this->_check_translated_response([], ApiResponseConstant::CALL_RECORDING_ASSOCIATE_USER_TO_ROLE);
                }
            } elseif($this->_calculateDissociationRules($service_set_value, $oldServiceSetValue)) {
                try {
                    $callRecordingRoleDetails = [
                        'call_recording_user_id' => $subscriber_details['call_recording_xid'],
                        'call_recording_role_id' => CallRecordingRoleDao::getRoleIDByCallRecordingUserID(
                            $connection,
                            $subscriber_details['call_recording_xid']
                            )
                    ];

                    $orecxProv->dissociateUsersToRole(
                        $connection,
                        $subscriber_details['prov_system_id'],
                        $callRecordingRoleDetails
                    );

                    CallRecordingRoleDao::setUserRole($connection, $subscriber_details['call_recording_xid'], null);
                } catch(Exception $e) {
                    $this->_error('Subscriber Facade -> _add_call_recording_user failed  for user ' . $user_id . 'Role dissociate failed.');
                    $this->_check_translated_response([], ApiResponseConstant::CALL_RECORDING_DISSOCIATE_USER_TO_ROLE);
                }
            }
        } else {
            if ($this->_isDebugEnabled()) {
                $this->_debug(" Subscriber Facade -> _update_call_recording_user failed  for user " . $user_id);
            }
            $this->_send_call_recording_notifications("Update", $group_details_as_array, $subscriber_details, "orecx=>updateUser() failed.");
            $this->_check_translated_response([], ApiResponseConstant::SUBSCRIBER_ADD_CALL_RECORDING_USER_CALL_FAILED);
        }

        if (UtilityMethods::isCallRecordingServiceBundleWithoutLS($service_set_value)) {
            $orecxGroupID = $orecxProv->getOrecxGroupID($connection, $subscriber_details['group_id']);
            if (!empty($orecxGroupID['orecx_group_id'])) {
                if (
                    isset($subscriber_details['callRecordingDetails'])
                    && isset($subscriber_details['callRecordingDetails']['organizationalGroupNames'])
                    && UtilityMethods::isNotEmpty($subscriber_details['callRecordingDetails']['organizationalGroupNames'])
                ) {
                    $subscriber_details['callRecordingSettings']['organizationalGroupIDs'] = [];
                    $subscriber_details['callRecordingData']['organizationalGroups'] = [];
                    $childOrganizationalGroups = $orecxProv->getChildOrganizationalGroups(
                        $connection,
                        $subscriber_details['prov_system_id'],
                        $orecxGroupID['orecx_group_id']
                    );
                    $subscriber_details['callRecordingDetails']['organizationalGroupNames'] = array_unique(
                        $subscriber_details['callRecordingDetails']['organizationalGroupNames']
                    );
                    foreach ($subscriber_details['callRecordingDetails']['organizationalGroupNames']
                             as $organizationalGroupName) {
                        foreach ($childOrganizationalGroups['objects'] as $group) {
                            if (UtilityMethods::isEqual($group['groupName'], $organizationalGroupName)) {
                                array_push(
                                    $subscriber_details['callRecordingSettings']['organizationalGroupIDs'],
                                    $group['id']);
                            }
                        }
                    }
                    $orecxUserID = CallRecMemberDao::get_call_recording_xid($connection, $subscriber_details['user_id']);
                    $orecxUserParentGroups = $orecxProv->getUserDetails(
                        $connection,
                        $subscriber_details,
                        $orecxUserID,
                        true
                    );
                    foreach ($orecxUserParentGroups["parentGroupDtos"] as $userGroups) {
                        array_push(
                            $subscriber_details['callRecordingData']['organizationalGroups'],
                            $userGroups);
                    }
                    $orecxProv->orecxGroupManagement(
                        $connection,
                        $subscriber_details,
                        $group_details,
                        CallRecordingConstant::UPDATE
                    );
					$subscriber_details['callRecordingSettings']['organizationalGroupNames'] = implode('|', $subscriber_details['callRecordingDetails']['organizationalGroupNames']);
                } else if (isset($subscriber_details['callRecordingDetails'])
                    && isset($subscriber_details['callRecordingDetails']['organizationalGroupNames'])
                    && UtilityMethods::isEmpty($subscriber_details['callRecordingDetails']['organizationalGroupNames'])) {
                    $orecxProv->orecxGroupManagement(
                        $connection,
                        $subscriber_details,
                        $group_details,
                        CallRecordingConstant::UPDATE
                    );
					$subscriber_details['callRecordingSettings']['organizationalGroupNames'] = '';
                } else if (isset($subscriber_details['callRecordingDetails'])
                    && isset($subscriber_details['callRecordingDetails']['securityGroup'])
                ) {
                    $role = $subscriber_details['callRecordingDetails']['securityGroup'];
                    if (empty($role)) {
                        $roleID = CallRecordingConstant::USER_ROLE_ID;
                    } else {
                        $roleID = CallRecordingRoleDao::getRoleIDByName($connection, $role);
                        if (empty($roleID)) {
                            $roleID = CallRecordingConstant::USER_ROLE_ID;
                        }
                    }
                    $subscriberRoleID = CallRecordingRoleDao::getRoleIDByUserID(
                        $connection,
                        $subscriber_details['user_id']
                    );

                    if (UtilityMethods::isNotEqual(intval($subscriberRoleID), intval($roleID))) {
                        $callRecordingRoleDetails = [
                            'call_recording_user_id' => $subscriber_details['call_recording_xid'],
                            'call_recording_role_id' => $roleID
                        ];
                        $orecxProv->associateUsersToRole(
                            $connection,
                            $subscriber_details['prov_system_id'],
                            $callRecordingRoleDetails
                        );
                        CallRecordingRoleDao::setUserRole(
                            $connection,
                            $subscriber_details['call_recording_xid'],
                            $roleID
                        );
                    }
                } else if (isset($subscriber_details['callRecordingSettings'])) {
                    $orecxProv->orecxGroupManagement(
                        $connection,
                        $subscriber_details,
                        $group_details,
                        CallRecordingConstant::UPDATE
                    );
                }
            } else {
                $subscriber_details['callRecordingSettings']['organizationalGroupIDs'] = [];
                $orecxProv->orecxGroupManagement(
                    $connection,
                    $subscriber_details,
                    $group_details,
                    CallRecordingConstant::SAVE
                );

                $oldCallRecordingSettings = $subscriber_details['callRecordingData'];
                $newCallRecordingSettings = $subscriber_details['callRecordingSettings'];

                if (!empty($oldCallRecordingSettings['securityGroup']) &&
                    UtilityMethods::isNotEqual(
                        $oldCallRecordingSettings['securityGroup'],
                        $newCallRecordingSettings['securityGroup'])
                ) {
                    $role = $newCallRecordingSettings['securityGroup'];
                    if (empty($role) || UtilityMethods::isEqual($role, CallRecordingConstant::ROLE_ADMINSTRATORS)) {
                        $roleID = CallRecordingConstant::USER_ROLE_ID;
                    } else {
                        $roleID = CallRecordingRoleDao::getRoleIDByName($connection, $role);
                        if (empty($roleID)) {
                            $roleID = CallRecordingConstant::USER_ROLE_ID;
                        }
                    }
                    $subscriberRoleID = CallRecordingRoleDao::getRoleIDByUserID(
                        $connection,
                        $subscriber_details['user_id']
                    );
                    if (UtilityMethods::isNotEqual($subscriberRoleID, $roleID)) {
                        $callRecordingRoleDetails = [
                            'call_recording_user_id' => $subscriber_details['call_recording_xid'],
                            'call_recording_role_id' => $roleID
                        ];
                        $orecxProv->associateUsersToRole(
                            $connection,
                            $subscriber_details['prov_system_id'],
                            $callRecordingRoleDetails
                        );
                        CallRecordingRoleDao::setUserRole(
                            $connection,
                            $subscriber_details['call_recording_xid'],
                            $roleID
                        );
                    }
                }
            }
        }

        CallRecMemberDao::updateOrganizationalGroupNames(
            $connection,
            $subscriber_details['callRecordingSettings']['organizationalGroupNames'],
            $subscriber_details['call_recording_xid']
        );

        // Unset the internal variables
        unset($subscriber_details["extended_userids"]);
    }


    /**
     * Remove recording user from orecx
     */
    private function _delete_call_recording_user($connection, $group_details, $subscriber_details, &$call_executed_list)
    {
        $orecxProv = new models\external\prov\Orecx();
        $call_recording_response = null;
        $group_details_as_array = GroupDao::get_group_details_for_update($connection, $subscriber_details['group_id'], false);
        $group_details = GroupDao::get_group_details_for_update($connection, $subscriber_details['group_id']);
        // Save the orecx subscriber identifier to the system.
        $subscriber_details["call_recording_xid"] = CallRecMemberDao::get_call_recording_xid($connection, $subscriber_details['user_id']);
        $orecxProv->deleteUserFromGroup($connection, $group_details, $subscriber_details);
        if (isset($subscriber_details['call_recording_xid'])) {
            $call_recording_id = $subscriber_details['call_recording_xid'];
            $user_id = $subscriber_details['user_id'];
            if ($this->_isDebugEnabled()) {
                $this->_debug(" Subscriber Facade -> _delete_call_recording_user succeeded  for user " . $user_id . " call_recording_id " . $call_recording_id);
            }
            CallRecMemberDao::delete_mapping($connection, $user_id, $call_recording_id);
            $call_executed_list[] = "_delete_call_recording_user => deleteUser";
            $this->_send_call_recording_notifications("Delete", $group_details, $subscriber_details, "");
        }
        CallRecMemberDao::delete_mapping($connection, $subscriber_details['user_id']);
    }

    /**
     * Check to see if API Consumer OR API CallMe product is assigned to subscriber
     *
     * @param $service_set_value
     * @return boolean
     */
    private function _isApiConsumerOrApiCallMeServiceBundle($service_set_value) {
        return UtilityMethods::isApiConsumerOrApiCallMeServiceBundle($service_set_value);
    }

    private function _get_domain_name($group_details) {
    	$domain_name = $group_details->top_level_domain;
    	if (UtilityMethods::isSMB ( $group_details->group_type )) {
    		$domain_name = $group_details->smb_prefix . "." . $group_details->top_level_domain;
    	}
    	return $domain_name;
    }

    /**
     * delete_device_buttons_provisioned function before deletion of subscriber checks if subscriber has device buttons provisioned or if is a target subscriber and do necessary clean up
     * @param $connection - db connection
     * @param $group_details - group details subscriber belongs to
     * @param $subscriber_details - subscriber details of subscriber to be deleted
     */
    public function delete_device_buttons_provisioned($connection, $group_details, $subscriber_details)
    {
     	$return_array = array();
     	//check if subscriber has device buttons set
     	$devices_with_keys_provisioned = SubscriberDao::get_subscriber_devices_for_button_keys($connection, $subscriber_details['subscriber_id']);
     	//check if subscriber is a target subscriber for any device buttons
     	$device_buttons_subscriber = array();
     	array_push($device_buttons_subscriber, $subscriber_details['user_id']);
     	$dev = new DeviceButtonFacade();
     	//if subscriber we attempting to delete has device buttons set clear all the buttons
     	if(!empty($devices_with_keys_provisioned)){
     		$device_button_facade = new DeviceButtonFacade();
     		$deleted_buttons = array();
     		foreach ($devices_with_keys_provisioned as $device){
     			//Get list KEMs of device
     			$list_kem = $device_button_facade->get_list_added_kem($device['mac_address']);
     			$list_kem[]['terminal_kem_mapping_id'] = "0";
 				foreach ($list_kem as $kem){
 					//Getting needed information in case of rollback
 					$old_device_buttons_provisioning = $device_button_facade->get_device_button_details($group_details->group_id, $device['mac_address'], $kem['terminal_kem_mapping_id']);
 					$sbp_details_old = DeviceButtonsDao::get_device_buttons_details_and_kem_by_mac($connection, strtoupper($device['mac_address']), "*", $kem['terminal_kem_mapping_id']);
 					if(!array_key_exists($device['mac_address'], $deleted_buttons)) {
	     				$deleted_buttons[$device['mac_address']]['sbp_details_old'] = array();
	     				$deleted_buttons[$device['mac_address']]['old_device_buttons_provisioning'] = array();
	     			}
	     			$deleted_buttons[$device['mac_address']]['sbp_details_old'][$kem['terminal_kem_mapping_id']] = $sbp_details_old;
	     			foreach ($old_device_buttons_provisioning["buttonkeys_list"] as &$function_value) {
	     				foreach ($function_value as $key => &$button) {
	     					$button['terminal_kem_mapping_id'] = $kem['terminal_kem_mapping_id'];
	     				}
	     			}
 					$deleted_buttons[$device['mac_address']]['old_device_buttons_provisioning'][$kem['terminal_kem_mapping_id']] = $old_device_buttons_provisioning;
 				}
				$device_button_facade->clear_all_buttons($group_details->group_id, $device['mac_address']);
 				$device_button_facade->remove_kem($device['mac_address'], "0", true);
				//Clear Group Params
				$device_parameter_group_device_details = DeviceParameterDao::get_device_parameter_group_device_details($connection, $group_details->group_id, $device['mac_address']);
				foreach ($device_parameter_group_device_details as $key => $value) {
					DeviceParameterDao::delete_device_from_device_parameter_group($connection, $value["terminal_id"]);
				}
     		}
     		// we want to return all device buttons we removed in case rollback is needed
     		$return_array['buttons_removed'] = $deleted_buttons;
     	}
     	//check if subscriber is set as target subscriber for someone elses device buttons
     	$set_as_target_subscriber_for_device_keys = DeviceButtonsDao::get_device_button_details_by_target_subscriber($connection, $device_buttons_subscriber);
     	// if subscriber is set as target subscriber on device keys, delete that subscriber and make those keys UNASSIGNED
     	if(!empty($set_as_target_subscriber_for_device_keys)){
     		$device_button_facade = new DeviceButtonFacade();
     		$device_button_facade->remove_blf_lines_set($connection, $set_as_target_subscriber_for_device_keys, $group_details->group_id);
     		// we want to return all the lines we have removed in case rollback is needed
     		$return_array['lines_removed'] = $set_as_target_subscriber_for_device_keys;
     	}
     	return $return_array;
    }

    public function get_restricted($user_id) {
        $group_id = CommonHelper::getContextValue('group_id');
        $connection = DbConnector::getConnection();
        return SubscriberDao::get_restricted($connection, $group_id, $user_id);
    }
    /**
     * this function gets voip phone numbers of the subscriber that are used as target numbers for Device Key Features (BLF, BLF_SPEED_DIAL, CALL_PARK_DIRECTED)
     *
     * @param $connection
     * @param $user_id
     * @param $group_id
     */
    public function get_device_buttons_target_numbers($connection, $user_id, $group_id) {
        // check if subscriber is set as target subscriber for someone elses device buttons
        $device_buttons_subscriber = array ();
        $phone_numbers_set_as_target = array ();
        array_push ( $device_buttons_subscriber, $user_id );
        $set_as_target_subscriber_for_device_keys = DeviceButtonsDao::get_device_button_details_by_target_subscriber ( $connection, $device_buttons_subscriber );
        if (isset ( $set_as_target_subscriber_for_device_keys )) {
            $device_parameters_for_target_sub = array ();

            foreach ( $set_as_target_subscriber_for_device_keys as $keys ) {
                if ($keys ['feature'] == DeviceParameterConstant::BLF || $keys ['feature'] == DeviceParameterConstant::BLF_SPEED_DIAL || $keys ['feature'] == DeviceParameterConstant::CALL_PARK) {
                    array_push ( $device_parameters_for_target_sub, $keys ['device_param_id'] );
                }
            }
            if (isset ( $device_parameters_for_target_sub )) {
                foreach ( $device_parameters_for_target_sub as $id ) {
                    $param_details = DeviceParameterDao::get_manage_parameter_details ( $connection, $id );
                    // if the parameter is a SET and matches the EFK label string, we need to get the prone number
                    if (preg_match ( DeviceParameterConstant::ATTENDANT_RESOURCE_CALL_ADDRESS_REGEX, $param_details ['parameter'] ) && strcmp ( $param_details ['action'], "set" ) == 0) {
                        array_push ( $phone_numbers_set_as_target, $param_details ['value'] );
                        continue;
                    } elseif (preg_match ( DeviceParameterConstant::YEALINK_LINEKEY_VALUE_STRING_REGEX, $param_details ['parameter'] ) && strcmp ( $param_details ['action'], "set" ) == 0) {
                        array_push ( $phone_numbers_set_as_target, $param_details ['value'] );
                    } elseif(preg_match(DeviceParameterConstant::EFK_ACTION_STRING_REGEX, $param_details['parameter'])
                            && strcmp($param_details['action'], "set") == 0) {
                                $deviceButtonFacade = new DeviceButtonFacade();
                                $vsc_value = $deviceButtonFacade->getVsc($group_id, DeviceParameterConstant::CALL_PARK_DIRECTED);
                                $call_park_dn_regex = str_ireplace(
                                    UtilityMethods::getVSCReplacePattern($vsc_value, '<CALL_PARK_VSC>'),
                                    $vsc_value,
                                    DeviceParameterConstant::CALL_PARK_DIRECTED_ACTION_REGEX
                                );
                                $regex_matches = array();
                                preg_match($call_park_dn_regex, $param_details['value'], $regex_matches);
                                if(count($regex_matches) < 2) {
                                    $response_array['ERROR_CODE'] = ApiResponseConstant::UNKNOWN_ERROR_OCCURRED;
                                    return $response_array;
                                }
                                array_push ( $phone_numbers_set_as_target, $regex_matches[1]);
                                continue;
                    } elseif (preg_match ( DeviceParameterConstant::YEALINK_LINEKEY_VALUE_STRING_REGEX, $param_details ['parameter'] ) && strcmp ( $param_details ['action'], "set" ) == 0) {
                        array_push ( $phone_numbers_set_as_target,  str_replace ( $vsc_value, "", $param_details ['value'] ));

                    }
                }
                unset ( $id );
            }
        }
        return $phone_numbers_set_as_target;
    }

    /**
     * this function removes device buttons provisioned against voip phone numbers that are being removed from the subscriber(BLF, BLF_SPEED_DIAL, CALL_PARK_DIRECTED)
     *
     * @param $connection
     * @param $user_id
     * @param $group_id
     */
    public function remove_device_buttons_by_target_numbers($connection, $user_id, $group_id, $target_numbers_to_be_removed) {
        // check if subscriber is set as target subscriber for someone elses device buttons
        $device_buttons_subscriber = array ();
        $phone_numbers_set_as_target = array ();
        array_push ( $device_buttons_subscriber, $user_id );
        $set_as_target_subscriber_for_device_keys = DeviceButtonsDao::get_device_button_details_by_target_subscriber ( $connection, $device_buttons_subscriber );
        if (isset ( $set_as_target_subscriber_for_device_keys )) {
            $device_parameters_for_target_sub = array ();

            foreach ( $set_as_target_subscriber_for_device_keys as $keys ) {
                if ($keys ['feature'] == DeviceParameterConstant::BLF || $keys ['feature'] == DeviceParameterConstant::BLF_SPEED_DIAL || $keys ['feature'] == DeviceParameterConstant::CALL_PARK) {
                    array_push ( $device_parameters_for_target_sub, $keys );

                }
            }


            if (isset ( $device_parameters_for_target_sub )) {
                foreach ( $device_parameters_for_target_sub as $id ) {
                    foreach($target_numbers_to_be_removed as $numb){
                        $param_details = DeviceParameterDao::get_manage_parameter_details ( $connection, $id['device_param_id'] );
                        // if the parameter is a SET and matches the EFK label string, we need to get the prone number
                        if (preg_match ( DeviceParameterConstant::ATTENDANT_RESOURCE_CALL_ADDRESS_REGEX, $param_details ['parameter'] ) && $numb ==$param_details ['value'] ) {

                            array_push ( $phone_numbers_set_as_target, $param_details['device_parameter_id']);
                            continue;
                        } elseif (preg_match ( DeviceParameterConstant::YEALINK_LINEKEY_VALUE_STRING_REGEX, $param_details ['parameter'] ) && strcmp ( $param_details ['action'], "set" ) == 0 && $numb ==$param_details ['value'] ) {
                            array_push ( $phone_numbers_set_as_target, $param_details['device_parameter_id'] );
                        } elseif(preg_match(DeviceParameterConstant::EFK_ACTION_STRING_REGEX, $param_details['parameter'])
                                && strcmp($param_details['action'], "set") == 0) {
                                    $deviceButtonFacade = new DeviceButtonFacade();
                                    $vsc_value = $deviceButtonFacade->getVsc($group_id, DeviceParameterConstant::CALL_PARK_DIRECTED);
                                    $call_park_dn_regex = str_ireplace(
                                        UtilityMethods::getVSCReplacePattern($vsc_value, '<CALL_PARK_VSC>'),
                                        $vsc_value,
                                        DeviceParameterConstant::CALL_PARK_DIRECTED_ACTION_REGEX
                                    );
                                    $regex_matches = array();
                                    preg_match($call_park_dn_regex, $param_details['value'], $regex_matches);
                                    if(count($regex_matches) < 2) {
                                        $response_array['ERROR_CODE'] = ApiResponseConstant::UNKNOWN_ERROR_OCCURRED;
                                        return $response_array;
                                    }
                                    if($regex_matches[1] == $numb){
                                        array_push ( $phone_numbers_set_as_target, $param_details['device_parameter_id']);
                                    }
                                    continue;
                        } elseif (preg_match ( DeviceParameterConstant::YEALINK_LINEKEY_VALUE_STRING_REGEX, $param_details ['parameter'] ) && strcmp ( $param_details ['action'], "set" ) == 0
                                && str_replace ( $vsc_value, "", $param_details ['value'] ) == $numb) {
                                    array_push ( $phone_numbers_set_as_target,  $param_details['device_parameter_id']);

                        }
                    }
                }
                unset ( $id );
            }
        }

        if(isset($phone_numbers_set_as_target)){
            array_unique($phone_numbers_set_as_target);
            foreach ($phone_numbers_set_as_target as $param_id){
                $line_data = DeviceButtonsDao::get_function_data_for_param_id($connection, $param_id );
                if(!empty($line_data)) {
                    $associated_param_ids = DeviceButtonsDao::get_all_param_ids_for_line_on_mac($connection, $line_data['line_key_idx'], $line_data['mac_address']);
                    DeviceButtonsDao::remove_line_key_for_mac($connection, $line_data['line_key_idx'], $line_data['mac_address']);

                    $parameters = array(
                            'feature'=>DeviceParameterConstant::RESERVED,
                            'mac_address'=>$line_data['mac_address'],
                            'line_key_idx'=>$line_data['line_key_idx'],
                            'device_param_id'=>null,
                            'speed_dial_idx'=>null,
                            'target_subscriber_id'=>null,
                            'terminal_kem_mapping_id'=>$line_data['terminal_kem_mapping_id']
                    );
                    DeviceButtonsDao::insert_parameter($connection, $parameters);
                }
            }
        }
        return $device_parameters_for_target_sub;
    }

    public function is_contain_alpha_numeric_password($sku_list){
        try{
            $connection = DbConnector::getConnection ();
            $services = "";
            $return_array = array();
            $return_array['is_standalone_voicemail_alpha_numeric_password'] = false;
            if(!is_null($sku_list)){
                $sku_array = explode(",", $sku_list);
                $list_selected_service_set = ProductDao::get_service_set_value_by_skus($connection,$sku_array);
                if(is_array($list_selected_service_set) && !empty($list_selected_service_set)){
                    foreach($list_selected_service_set as $key => $value){
                        $services .= $value['service_set_value'] . "|";
                    }
                    $services = rtrim($services,"|");
                    $return_array['is_standalone_voicemail_alpha_numeric_password'] = UtilityMethods::is_standalone_voicemail_alpha_numeric_password_bundle($services);
                }
            }
                return $return_array;
            } catch ( Exception $e ) {
            // catching Error
            if ($this->_isErrorEnabled ()) {
                $this->_error ( "Check service set failed!", $e );
            }
            throw $e;
        }
    }

    public function is_contain_no_mailbox($sku_list){
        try{
            $connection = DbConnector::getConnection ();
            $services = "";
            $return_array = array();
            $return_array['is_contain_vr_no_mailbox'] = false;
            if(!empty($sku_list)){
                $sku_array = explode(",", $sku_list);
                $list_selected_service_set = ProductDao::get_service_set_value_by_skus($connection,$sku_array);
                if(is_array($list_selected_service_set) && !empty($list_selected_service_set)){
                    foreach($list_selected_service_set as $key => $value){
                        $services .= $value['service_set_value'] . "|";
                    }
                    $services = rtrim($services,"|");
                    $return_array['is_contain_vr_no_mailbox'] = UtilityMethods::is_no_mailbox_bundle($services);
                }
            }
            return $return_array;
        } catch ( Exception $e ) {
            // catching Error
            if ($this->_isErrorEnabled ()) {
                $this->_error ( "Check service set failed!", $e );
            }
            throw $e;
        }
    }

    /**
     * Check provided skus are containing a2 service
     *
     * @param $sku_list
     *
     * @return array
     * @throws Exception
     */
    public function is_PA_sso_needed($sku_list = [])
    {
    	try{
    		$connection = DbConnector::getConnection();

    		// prepare default response
    		$return_array = [
    				'is_PA_sso_needed' => false
    		];

    		// check provided param
    		if(!empty($sku_list) && is_array($sku_list) && count($sku_list) > 0){

    			$service_set_array = [];

    			// get service sets from sku
    			$list_selected_service_set = ProductDao::get_service_set_value_by_skus($connection, $sku_list);
    			if(is_array($list_selected_service_set) && !empty($list_selected_service_set)){
    				// get service set values from service_set list
    				foreach ($list_selected_service_set as $service_set){
    					$service_set_array[] = $service_set['service_set_value'];
    				}

    				$service_menu_names = ProductDao::is_standalone_voicemail_menu($connection, $service_set_array);
    				$is_standalone_service = false;
    				foreach ($service_menu_names as $key => $value) {
    					if (UtilityMethods::is_standalone_voicemail_menu_bundle ( $value['menu_name'])) {
    						$is_standalone_service = true;
    						break;
    					}
    				}
    				if(!$is_standalone_service) {
    					$list_selected_a2_services = ServiceSetDao::get_a2_services_by_service_set_value($connection, $list_selected_service_set[0]);
    					if(!empty($list_selected_a2_services)){
    						$return_array['is_PA_sso_needed'] = true;
    					}
    				}
    			}
    		}
    		return $return_array;
    	}catch (Exception $e){
    		// catching Error
    		if ($this->_isErrorEnabled ()) {
    			$this->_error ( "Check service set failed!", $e );
    		}
    		throw $e;
    	}
    }

    /**
     * Method to check the request owner is IT operation or not
     *
     * @return bool
     */
    public function isItOperation(): bool
    {
        $intersects = count(
            array_intersect(
                [PermissionConstant::IT_OPERATIONS_PERMISSION],
                CommonHelper::getPresentationValue("permissions")
            )
        );
        return $intersects > 0;
    }

    public function check_device_assigned($list_devices){
        try{
            $connection = DbConnector::getConnection ();
            $param = "";
            $return_array = array();
            $save_list_devices = $list_devices;
			foreach($list_devices as $key => $device){
				$list_devices[$key] = '"'.str_replace(":","",$device).'"';
			}
			$param = implode(",",$list_devices);
			$return_array['list_device'] = TerminalsDao::check_device_assigned($connection, $param);
			while ($device = current($list_devices)) {
				$device = str_replace('"','',$device);
			    if ($device == $return_array['list_device'][0]) {
					$return_array['key'] = key($list_devices);
					break;
			    }
			    next($list_devices);
			}
			return $return_array;
        } catch ( Exception $e ) {
            // catching Error
            if ($this->_isErrorEnabled ()) {
                $this->_error ( "Check device watting to add failed!", $e );
            }
            throw $e;
        }
    }

    public function check_device_availability($list_devices, $user_and_group_id) {
        try {
            $connection = DbConnector::getConnection();
            $sub_id = "";
            $param = array();
            $return_array = array();

            if (!empty($user_and_group_id) && isset($user_and_group_id['user_id'])) {
                $subscriber_details = SubscriberDao::findSubscriber($connection, $user_and_group_id['user_id'], $user_and_group_id['group_id']);
                $sub_id = $subscriber_details->subscriber_id;
            }

            foreach ($list_devices as $key => &$device) {
                $list_devices[$key] = array(
                    '"' . str_replace(":", "", $device) . '"' => $device
                );

                array_push($param, key($list_devices[$key]));
            }

            $param = implode(",", $param);

            $terminal_details = TerminalsDao::get_terminal_details_for_device_availability($connection, $param);

            if (count($list_devices) > count($terminal_details)) {

                $device_array_list = array();
                foreach ($terminal_details as $key => &$details_array) {
                    array_push($device_array_list, $details_array['mac_address']);
                }

                foreach ($list_devices as $key => &$value) {
                    if (!in_array(str_replace('"', "", key($value)), $device_array_list, true)) {
                        $invalidDevices_array = array(
                            'mac' => $value[key($value)],
                            'reasonCode' => ApiResponseConstant::INVALID_MAC_ADDRESS,
                            'rcMessage' => 'Device does not exist'
                        );
                        array_push($return_array, $invalidDevices_array);
                        unset($list_devices[$key]);
                    }
                }
                $list_devices = array_values($list_devices);
            }

            foreach ($list_devices as $key => &$device_array) {
                foreach ($terminal_details as $key => &$details_array) {
                    if (UtilityMethods::isEqual(str_replace('"', "", key($device_array)), $details_array['mac_address'])) {
                        $mac_address = $device_array['"' . $details_array['mac_address'] . '"'];
                        $subscriber_id = $details_array['subscriber_id'];
                        $prov_in_progress = $details_array['prov_in_progress'];
                        $assigned_to_group_id = $details_array['assigned_to_group_id'];

                        if (UtilityMethods::isNotEqual($assigned_to_group_id, $user_and_group_id['group_id'])) {
                            $invalidDevices_array = array(
                                'mac' => $mac_address,
                                'reasonCode' => ApiResponseConstant::INVALID_MAC_ADDRESS,
                                'rcMessage' => 'Device does not exist'
                            );

                            array_push($return_array, $invalidDevices_array);

                        } elseif ((!empty($subscriber_id) && (UtilityMethods::isNotEqual($sub_id, $subscriber_id))) && ($prov_in_progress == 0)) {
                            $invalidDevices_array = array(
                                'mac' => $mac_address,
                                'reasonCode' => ApiResponseConstant::DEVICE_ALREADY_ASSIGNED_TO_SUBSCRIBER,
                                'rcMessage' => 'Device belongs to other Subscriber'
                            );

                            array_push($return_array, $invalidDevices_array);

                        } elseif (empty($subscriber_id) && ($prov_in_progress == 1)) {
                            $invalidDevices_array = array(
                                'mac' => $mac_address,
                                'reasonCode' => ApiResponseConstant::DEVICE_WAITING_FOR_PROVISION_RESPONSE,
                                'rcMessage' => 'Device in Waiting for Provision Response state'
                            );

                            array_push($return_array, $invalidDevices_array);

                        } elseif (empty($subscriber_id) && ($prov_in_progress == 3)) {
                            $invalidDevices_array = array(
                                'mac' => $mac_address,
                                'reasonCode' => ApiResponseConstant::DEVICE_WAITING_TO_DELETE,
                                'rcMessage' => 'Device in Waiting to delete state'
                            );

                            array_push($return_array, $invalidDevices_array);

                        } elseif (empty($subscriber_id) && ($prov_in_progress == 4)) {
                            $invalidDevices_array = array(
                                'mac' => $mac_address,
                                'reasonCode' => ApiResponseConstant::DEVICE_WAITING_TO_MIGRATE,
                                'rcMessage' => 'Device in Waiting to migrate state'
                            );

                            array_push($return_array, $invalidDevices_array);

                        } elseif (empty($subscriber_id) && ($prov_in_progress == 5)) {
                            $invalidDevices_array = array(
                                'mac' => $mac_address,
                                'reasonCode' => ApiResponseConstant::DEVICE_FAILED_TO_ADD,
                                'rcMessage' => 'Device in Failed to add state'
                            );

                            array_push($return_array, $invalidDevices_array);

                        } elseif (empty($subscriber_id) && ($prov_in_progress == 6)) {
                            $invalidDevices_array = array(
                                'mac' => $mac_address,
                                'reasonCode' => ApiResponseConstant::DEVICE_FAILED_TO_DELETE,
                                'rcMessage' => 'Device in Failed to delete state'
                            );

                            array_push($return_array, $invalidDevices_array);

                        } elseif (!empty($subscriber_id) && UtilityMethods::isEqual($prov_in_progress, TerminalsConstant::PROV_IN_PROGRESS_ADD_ZTP)) {
                            $invalidDevices_array = [
                                'mac' => $mac_address,
                                'reasonCode' => ApiResponseConstant::DEVICE_ASSIGNED_BUT_WAITING_TO_ADD,
                                'rcMessage' => 'Device in Waiting to add state and belongs to other Subscriber'
                            ];
                            array_push($return_array, $invalidDevices_array);
                        }
                        break;
                    }
                }
            }

            return $return_array;
        } catch (Exception $e) {
            // catching Error
            if ($this->_isErrorEnabled()) {
                $this->_error("Check device availability failed!", $e);
            }
            throw $e;
        }
    }

    //Insert session subscriber user portal
    public function insert_session_subscriber_EUP($param) {
        try{
            $response = '';
            $connection = DbConnector::getConnection();
            $response = SubscriberDao::insert_session_subscriber_user_portal($connection, $param);
        }
        catch ( Exception $e ){
            // catching Error
            if ($this->_isErrorEnabled ()) {
                $this->_error ( "Insert session subscriber EUP failed!", $e );
            }
            throw $e;
        }
    }

	public function is_duplicate_subcriber_user_id_and_alias($group_id,$param,$domain){
		if(empty($param)) return false;

		$connection = DbConnector::getConnection ();
		$all_user_id = array_column(SubscriberDao::get_all_subscriber_id_for_group($connection, $group_id),'user_id');
		$all_voice_alias = array_column(SubscriberDao::get_all_voice_alias_by_group_id($connection, $group_id),'voice_alias');
		$pattern = '/^'.str_replace('@'.$domain, '', $param).'$/';

		foreach($all_user_id as $user_id){
			if(preg_match($pattern,str_replace('@'.$domain, '', $user_id)) == 1){
				return 1;
			}
		}
		foreach($all_voice_alias as $voice_alias){
			if(preg_match($pattern,str_replace('@'.$domain, '', $voice_alias)) == 1){
				return 2;
			}
		}
		return false;
	}

	/**
     *
     * Return the error if user_id matches an existing Group Name, user alias or service alias
     *
     * @param unknown $connection
     * @param unknown $group_id
     * @param unknown $user_id
     */
    public function check_possessor_of_user_id($connection, $group_id, $user_id) {
        // MUST not match any CAG "Group Name" as seen in the portal CAG screen, for any CAG in the same SMB or ORG.
        $cags = CallRoutingDao::get_cag_by_group_name($connection, $user_id, $group_id);
        if (count($cags) > 0) {
            return $this->_build_error_message(ApiResponseConstant::USER_ID_ALREADY_IN_USE_BY_ANOTHER_NAME_CAG,$user_id);
        }

        // MUST not match any CAG "Aliases" as seen in the portal CAG screen, for any CAG in the same SMB or ORG.
        $cag_names = CallRoutingDao::get_all_call_group($connection, $group_id, array(CommonConstant::QUERY_PARAM_SEARCH_KEYWORD => NULL, CommonConstant::QUERY_PARAM_SORT_BY => NULL), 'name');
        $cag_details = array();
        $cag_name_possessor = "";
        $cag_facade = new CallRoutingFacade();
        foreach ($cag_names as $element) {
            $group_name = $element['name'];
            $cag_details[] = $cag_facade->get_call_group_details($group_id,$group_name,false);
        }
        foreach ($cag_details as $cag_detail) {
            // when create new Call Pickup, the alias always is empty string, so need to check is_array
            if(is_array($cag_detail['aliases']) && in_array($user_id, $cag_detail['aliases'])){
                $cag_name_possessor = $cag_detail['name'];
                break;
            }
        }
        if(!empty($cag_name_possessor)){
            $error_subs = array();
            array_push($error_subs,$user_id);
            array_push($error_subs,$cag_name_possessor);
            return $this->_build_error_message(ApiResponseConstant::USER_ID_ALREADY_IN_USE_BY_ANOTHER_ALIAS_OF_CAG,$error_subs);
        }
        return 'NONE_POSSESSOR';
    }

    /**
     * delete_softkeys_provisioned function before deletion of subscriber checks if subscriber is a target subscriber and do necessary clean up
     * @param $connection - db connection
     * @param $group_details - group details subscriber belongs to
     * @param $subscriber_details - subscriber details of subscriber to be deleted
     */
    public function delete_softkeys_provisioned($connection, $group_details, $subscriber_details)
    {
        $return_array = array();
        //check if subscriber has softkeys set
        $devices_with_keys_provisioned = SubscriberDao::get_subscriber_devices_for_button_keys($connection, $subscriber_details['subscriber_id']);
        //check if subscriber is a target subscriber for any device buttons
        $device_buttons_subscriber = array();
        array_push($device_buttons_subscriber, $subscriber_details['user_id']);
        $device_button_facade = new DeviceButtonFacade();
        //check if subscriber is set as target subscriber for someone elses soft kyes
        $set_as_target_subscriber_for_soft_keys = DeviceButtonsDao::get_soft_key_macro_details_by_target_subscriber($connection, $device_buttons_subscriber);
        //need to get unigue mac address
        $mac_adress_array = array();
        if(isset($set_as_target_subscriber_for_soft_keys)){
            foreach($set_as_target_subscriber_for_soft_keys as $soft_keys){
                array_push($mac_adress_array, $soft_keys['mac_address']);
            }
        }
        $mac_adress_array = array_unique($mac_adress_array);
        $old_soft_key_details_array = array();
        foreach ($mac_adress_array as $mac){
            // get old soft key details in case of rollback
            $old_soft_key_details = $device_button_facade->get_soft_key_details ($group_details->group_id, $mac);
            $old_soft_key_details['mac_address'] = $mac;
            array_push($old_soft_key_details_array, $old_soft_key_details);
        }

        // if subscriber is set as target subscriber on device keys, delete that subscriber and make those keys UNASSIGNED
        if(!empty($set_as_target_subscriber_for_soft_keys)){
            $device_button_facade->remove_specific_soft_keys($connection, $set_as_target_subscriber_for_soft_keys, $group_details->group_id);
            // we want to return all the lines we have removed in case rollback is needed
            $return_array['soft_keys_removed'] = $set_as_target_subscriber_for_soft_keys;
        }

        //after we removed the softkeys we need to get them reprovisioned
        foreach($mac_adress_array as $new_mac){
            $new_device_buttons = $device_button_facade->get_soft_key_details($group_details->group_id, $new_mac);
            if(isset($new_device_buttons)){
                $vendor = $device_button_facade->get_vendor_name($new_mac);
                $device_button_facade->provision_soft_keys($vendor, $new_mac, $new_device_buttons, $group_details->group_id);
            }
        }

        $return_array['old_soft_key_details'] = $old_soft_key_details_array;
        return $return_array;
    }

    public function get_all_devices_status_by_full_user_id($full_user_id){
        $dashboard_degistration = new DashboardRegistrationFacade;
        $list_device_status = $dashboard_degistration->get_all_devices_status_by_full_user_id($full_user_id);
        foreach ($list_device_status as &$device_status){
            $device_status['mac_address'] = chunk_split($device_status['mac_address'],2,":");
            $device_status['mac_address']= rtrim($device_status['mac_address'],":");
            $device_status['mac'] = $device_status['mac_address'];
            unset($device_status['mac_address']);
            $device_status = array_reverse($device_status);
        }
        return $list_device_status;
	}

	//For deciding the minimum vm_pin digits
	public function decide_min_vm_pin_digits(){
		$response = CIM_PIN_MIN_LENGTH;
		return $response;
	}

    /**
     * @param       $event_type
     * @param       $group_details
     * @param array $subscriber_details
     * @param array $old_subscriber_details
     *
     * @return void
     */
    public function subscriber_historic_report($event_type, $group_details, $subscriber_details, $old_subscriber_details = [])
    {
        $this->_debug("Subscriber Facade -> subscriber_historic_report function is started for group_id: "
            . $subscriber_details['group_id'] . ' ,subcriber: ' . $subscriber_details['user_id'] . ' and event type is ' . $event_type);

        $historicReportFacade = new HistoricreportFacade();
        if ($historicReportFacade->trackChanges($group_details, HistoricReportConstant::REPORT_NAME_SUBSCRIBER_PROVISIONING_CHANGES)) {
            $connection = DbConnector::getConnection ();
            if (!isset($subscriber_details['domain']) || empty($subscriber_details['domain'])) {
                $subscriber_details['domain'] = $group_details->top_level_domain;
            }
            $subscriber_details['short_user_id'] = explode('@', $subscriber_details['user_id'])[0];
            $subscriber_details['sub_domain'] = $group_details->group_type == GroupConstant::GROUP_TYPE_SMB
                ? SmbDao::get_smb_prefix($connection, $group_details->group_id).'.'.$subscriber_details['domain']
                : $subscriber_details['domain'];

            if (isset($subscriber_details['devices']) && !empty($subscriber_details['devices'])) {
                $subscriber_details['devices'] = array_map(function($val) {
                    return strstr($val, ':') === false
                        ? preg_replace('/..(?!$)/i', "$0:", $val)
                        : $val;
                }, $subscriber_details['devices']);
            }

            if (isset($subscriber_details['voicemail_service'])) {
                $subscriber_details['voicemail_service'] = strtoupper($subscriber_details['voicemail_service']);
            }

            if ($event_type === ReportConstants::EVENT_TYPE_ADD) {
                $subscriber_details['primary_number'] = $subscriber_details['primary_voip_number'];
                $subscriber_details['service_access_status'] = $subscriber_details['default_status'];
                if (!isset($subscriber_details['public_charge_id']) || empty($subscriber_details['public_charge_id'])) {
                    $subscriber_details['public_charge_id'] = $subscriber_details['primary_number'];
                }
            }

            if ($event_type === ReportConstants::EVENT_TYPE_DELETE) {
                if (UtilityMethods::isEqual($subscriber_details['default_status'], ProvisioningConstant::DEFAULT_STATUS_INACTIVE)) {
                    $subscriber_details['service_access_status'] = ProvisioningConstant::DEFAULT_STATUS_INACTIVE;
                }
            }

            if ($event_type === ReportConstants::EVENT_TYPE_UPDATE) {
                $old_subscriber_details['short_user_id'] = $subscriber_details['short_user_id'];
                $old_subscriber_details['sub_domain'] = $subscriber_details['sub_domain'];

                if (!isset($subscriber_details['primary_number']) & isset($old_subscriber_details['primary_number'])) {
                    $subscriber_details['primary_number'] = $old_subscriber_details['primary_number'];
                }

                if (!isset($subscriber_details['public_charge_id']) & isset($old_subscriber_details['public_charge_id'])) {
                    $subscriber_details['public_charge_id'] = $old_subscriber_details['public_charge_id'];
                }

                if (isset($subscriber_details['primary_voip_number'])) {
                    $subscriber_details['primary_number'] = $subscriber_details['primary_voip_number'];
                }
                if (UtilityMethods::isEmpty($old_subscriber_details['primary_number'])) {
                    $old_subscriber_details['primary_number'] = !empty($old_subscriber_details['voip_numbers'])
                        ? $old_subscriber_details['voip_numbers'][0]
                        : '';
                }
                if (UtilityMethods::isEmpty($old_subscriber_details['public_charge_id'])) {
                    $old_subscriber_details['public_charge_id'] = isset($old_subscriber_details['primary_number'])
                        ? $old_subscriber_details['primary_number']
                        : !empty($old_subscriber_details['voip_numbers'])
                            ? $old_subscriber_details['voip_numbers'][0]
                            : '';
                }
                if (UtilityMethods::isEmpty($subscriber_details['primary_number'])) {
                    $subscriber_details['primary_number'] = UtilityMethods::isNotEqual($subscriber_details['voip_numbers'][0], $old_subscriber_details['voip_numbers'][0])
                        ? $subscriber_details['voip_numbers'][0]
                        : $old_subscriber_details['primary_number'];
                }
                if (UtilityMethods::isEmpty($subscriber_details['public_charge_id'])) {
                    $subscriber_details['public_charge_id'] = UtilityMethods::isNotEqual($subscriber_details['voip_numbers'][0], $old_subscriber_details['voip_numbers'][0])
                        ? $subscriber_details['voip_numbers'][0]
                        : $old_subscriber_details['public_charge_id'];
                }
                if (UtilityMethods::isEmpty($subscriber_details['allow_eup_config'])) {
                    $subscriber_details['allow_eup_config'] = $old_subscriber_details['allow_eup_config'];
                }
                if (isset($old_subscriber_details['voicemail_service'])) {
                    $old_subscriber_details['voicemail_service'] = strtoupper($old_subscriber_details['voicemail_service']);
                    $subscriber_details['voicemail_service'] = strtoupper($subscriber_details['voicemail_service']);
                    if ($old_subscriber_details['voicemail_service'] === 'PREMISE'
                        && !isset($old_subscriber_details['voicemail_number'])
                        || empty($old_subscriber_details['voicemail_number'])) {
                        $old_subscriber_details['voicemail_number'] = $old_subscriber_details['primary_number'];
                    }
                    if ($subscriber_details['voicemail_service'] !== 'PREMISE'
                        && $old_subscriber_details['voicemail_service'] === 'PREMISE') {
                        $subscriber_details['voicemail_number'] = '';
                    }
                    if ($subscriber_details['voicemail_service'] === 'PREMISE'
                        && $old_subscriber_details['voicemail_service'] !== 'PREMISE') {
                        $old_subscriber_details['voicemail_number'] = '';
                    }
                    if ($subscriber_details['voicemail_service'] !== 'PREMISE'
                        && $old_subscriber_details['voicemail_service'] === $subscriber_details['voicemail_service']) {
                        $old_subscriber_details['voicemail_number'] = '';
                        $subscriber_details['voicemail_number'] = '';
                    }
                }

                $old_subscriber_details['allow_eup_config'] = !isset($old_subscriber_details['allow_eup_config'])
                    || in_array($old_subscriber_details['allow_eup_config'], ['0', 'disabled'])
                        ? 'NO' : 'YES';

                if (isset($old_subscriber_details['devices']) && !empty($old_subscriber_details['devices'])) {
                    $old_subscriber_details['devices'] = array_map(function($val) {
                        return strstr($val, ':') === false
                            ? preg_replace('/..(?!$)/i', "$0:", $val)
                            : $val;
                    }, $old_subscriber_details['devices']);
                }

                if (
                    UtilityMethods::isEqual($subscriber_details['default_status'], ProvisioningConstant::DEFAULT_STATUS_INACTIVE)
                    && UtilityMethods::isEqual($old_subscriber_details['default_status'], ProvisioningConstant::DEFAULT_STATUS_INACTIVE)
                ) {
                    $subscriber_details['service_access_status'] = $subscriber_details['default_status'];
                    $old_subscriber_details['service_access_status'] = $old_subscriber_details['default_status'];
                }
            }

            if (empty($subscriber_details['primary_number'])) {
                $subscriber_details['primary_number'] = !empty($subscriber_details['voip_numbers'])
                    ? $subscriber_details['voip_numbers'][0]
                    : '';
            }

            if (UtilityMethods::isEmpty($subscriber_details['public_charge_id'])) {
                $subscriber_details['public_charge_id'] = $subscriber_details['primary_number'];
            }

            if (isset($subscriber_details['voicemail_service'])
                && empty($subscriber_details['voicemail_number'])
                && $subscriber_details['voicemail_service'] === 'PREMISE') {
                $subscriber_details['voicemail_number'] = $subscriber_details['primary_number'];
            }

            $subscriber_details['allow_eup_config'] = !isset($subscriber_details['allow_eup_config'])
                || in_array($subscriber_details['allow_eup_config'], ['0', 'disabled'])
                    ? 'NO' : 'YES';

            $subscriberReport = SubscriberReport::getInstance();
            $report = $subscriberReport->prepare($event_type, $subscriber_details, $old_subscriber_details);
            if ($subscriberReport->save($report)) {
                $this->_terminal_report_for_device_update(
                    $event_type, $report, $subscriberReport->getColumns()['devices'], $group_details, $subscriber_details
                );
                if ($this->_isDebugEnabled ()) {
                    $this->_debug ( "Subscriber Provisioning Changes have been saved.");
                }
            }
        }
    }

    /**
     * @param string  $event_type
     * @param array   $reports
     * @param string  $device_column
     * @param         $group_details
     * @param         $subscriber_details
     *
     * @return void
     */
    private function _terminal_report_for_device_update($event_type, array $reports, $device_column, $group_details, $subscriber_details)
    {
        if (empty($reports)) { return; }

        $connection = DbConnector::getConnection ();
        $terminalUpdateFunc = function($event, $terminal, $subscriber, $update_event = null) use ($connection, $group_details) {
            foreach($terminal as $mac) {
                $terminal_id = TerminalsDao::get_terminal_id_and_assigned_group_id_by_mac_address($connection, $mac, $group_details->group_id);
                if ($terminal_id) {
                    $old_terminal_details = TerminalsDao::get_terminal($connection, $group_details->group_id, $mac);
                    if (empty($old_terminal_details)) {
                        $old_terminal_details = TerminalsDao::get_terminal($connection, $group_details->parent_group_id, $mac);
                    }
                    $old_terminal_details['domain'] = $group_details->top_level_domain;
                    $old_terminal_details['sub_domain'] = $old_terminal_details['domain_name'];
                    $old_terminal_details['mac_address'] = preg_replace('/..(?!$)/i', '$0:', $old_terminal_details['mac_address']);
                    $old_terminal_details['subscriber_name'] = $subscriber['user_id'];
                    $terminal_details = $old_terminal_details;
                    if ($event === ReportConstants::EVENT_TYPE_ADD ||
                       ($event === ReportConstants::EVENT_TYPE_UPDATE && $update_event === 'add')) {
                        $old_terminal_details['subscriber_name'] = '';
                        $terminal_details['subscriber_name'] = $subscriber['user_id'];
                        TerminalsDao::update_mac_addr_for_provision_completed($connection, $terminal, $subscriber['subscriber_id']);
                    } elseif ($event === ReportConstants::EVENT_TYPE_DELETE ||
                             ($event === ReportConstants::EVENT_TYPE_UPDATE && $update_event === 'delete')) {
                        $old_terminal_details['subscriber_name'] = $subscriber['user_id'];
                        $terminal_details['subscriber_name'] = '';
                        TerminalsDao::removeMacAddressForSubscriber($connection, $subscriber['subscriber_id'], $terminal);
                    }
                    $terminalReport = TerminalReport::getInstance();
                    $report = $terminalReport->prepare(ReportConstants::EVENT_TYPE_UPDATE, $terminal_details, $old_terminal_details);
                    if ($terminalReport->save($report)) {
                        if ($this->_isDebugEnabled ()) {
                            $this->_debug ("Terminal Provisioning Changes have been saved.");
                        }
                    }
                }
            }
        };

        $macAddressFunc = function($terminal) {
            $terminal = array_filter(explode('|', $terminal), function($val) { return ! empty($val); });
            if (empty($terminal)) { return []; }
            return array_map(function($val) { return str_replace(':', '', $val); }, $terminal);
        };

        $prev_devices = null;
        $curr_devices = null;
        if (in_array($event_type, [ReportConstants::EVENT_TYPE_ADD, ReportConstants::EVENT_TYPE_DELETE])) {
            $curr_devices = $macAddressFunc($reports[0]['devices']);
            $terminalUpdateFunc($event_type, $curr_devices, $subscriber_details);
        } else {
            foreach ($reports as $report) {
                if ($report[ReportConstants::CHANGED_FIELD] === $device_column) {
                    $curr_devices = $macAddressFunc($report[ReportConstants::CURRENT_VALUE]);
                    $prev_devices = $macAddressFunc($report[ReportConstants::PREV_VALUE]);

                    $terminalUpdateFunc($event_type, array_diff($prev_devices, $curr_devices), $subscriber_details, 'delete');
                    $terminalUpdateFunc($event_type, array_diff($curr_devices, $prev_devices), $subscriber_details, 'add');
                    break;
                }
            }
        }
    }

    /**
     * Subscriber Menu List
     *
     * @param $serviceSetValue
     * @return mixed
     */
    public function getSubscriberMenu($serviceSetValue){
        $connection = DbConnector::getConnection();
        return  ProductDao::getSubscriberMenuByServiceSet($connection, $serviceSetValue);
    }

	private function _set_directory_number_error_response($response) {
		if (preg_match('/Directory number (.*) matches an existing/i', $response[ProvisioningConstant::A2_RESPONSE])) {
			throw new CallFailedException("", ApiResponseConstant::SET_DIRECTORY_NUMBER_DIRECTORY_NUMBER_MATCHES_AN_EXISTING);
		} else if (preg_match('/Alias (.*) matches an existing/i', $response[ProvisioningConstant::A2_RESPONSE])) {
			throw new CallFailedException("", ApiResponseConstant::SET_DIRECTORY_NUMBER_ALIAS_MATCHES_AN_EXISTING);
		} else if (preg_match('/Username (.*) matches an existing/i', $response[ProvisioningConstant::A2_RESPONSE])) {
			throw new CallFailedException("", ApiResponseConstant::SET_DIRECTORY_NUMBER_USERNAME_MATCHES_AN_EXISTING);
		}
	}

	private function _add_user_error_response($response) {
		if (preg_match('/addSingleUserWithServiceSet(.*)username(.*)matches an existing/i', $response [ProvisioningConstant::A2_RESPONSE])) {
			throw new CallFailedException("", ApiResponseConstant::FAILED_TO_ADD_USER_MATCHES_AN_EXISTING);
		} else if (preg_match('/Invalid Password/i', $response [ProvisioningConstant::A2_RESPONSE])) {
            throw new CallFailedException(
                substr($response [ProvisioningConstant::A2_RESPONSE],
                    strpos($response [ProvisioningConstant::A2_RESPONSE], 'Invalid Password')
                ),
                ApiResponseConstant::TRANSLATED_ERROR_MESSAGE
            );
		}
    }

    /**
     * Run Live Support Inbound Voice Provisioning.
     *
     * @param object $connection
     * @param array  $subscriberDetails
     * @param object $groupDetails
     * @param array  $callExecutedList
     * @return void
     * @throws CallFailedException|Exception
     */
    private function runLiveSupportInboundVoiceProvisioning($connection, $subscriberDetails, $groupDetails, &$callExecutedList)
    {
        $provLsInboundVoice = new ProvisioningLiveSupportInboundVoice($connection, $subscriberDetails, $groupDetails);
        $provLsInboundVoice->execute($callExecutedList);
    }

    /**
     * Delete Live Support Inbound Voice Provisioning.
     *
     * @param object $connection
     * @param array  $subscriberDetails
     * @param object $groupDetails
     * @return void
     * @throws Exception
     */
    private function deleteLiveSupportInboundVoiceProvisioning($connection, $subscriberDetails, $groupDetails)
    {
        $provLsInboundVoice = new ProvisioningLiveSupportInboundVoice($connection, $subscriberDetails, $groupDetails);
        $provLsInboundVoice->deleteAll();
    }

    /**
     * Method to set Call Permission and Call Forward Permission values
     *
     * @param array $subscriberDetails
     * @param string $subscriberFieldName
     *
     * @return void
     */
    private function setSubscriberCallPermissions(&$subscriberDetails, $subscriberFieldName)
    {
        if (UtilityMethods::isEqual($subscriberFieldName, 'call_permission')
            || UtilityMethods::isEqual($subscriberFieldName, 'call_forward_permission')) {
            if (UtilityMethods::isKbsApiCallMeServiceBundle($subscriberDetails['service_set_value'])) {
                $subscriberDetails[$subscriberFieldName] = SubscriberConstant::CALL_PERMISSION_SIP;
            } elseif (UtilityMethods::isKbsApiCallMePSTNServiceBundle($subscriberDetails['service_set_value'])) {
                $subscriberDetails[$subscriberFieldName] = SubscriberConstant::CALL_PERMISSION_PSTN;
            }
        }
    }

    /**
     * Auth Methods of All subscriber has been updated with this query
     * @param int $groupId
     * @param string $updatedVal
     * @throws Exception
     *
     * @return void
     */
    public function updateSubscribersAuthMethods($groupId, $updatedVal = SubscriberConstant::AUTHENTICATION_METHOD_BASIC)
    {
        $connection = DbConnector::getConnection();
        SubscriberDao::updateSubscribersAuthMethodsWithGroupId($connection, $groupId, $updatedVal);
    }

    /**
     * check Subscriber Password Policy
     *
     * @param string $subscriberPassword
     * @param object $groupDetails
     *
     * @return array|bool
     * @throws Exception
     */
    public function checkSubscriberPasswordPolicy($subscriberPassword, $groupDetails)
    {
        $connection = DbConnector::getConnection();
        $provSystemID = $this->get_provisioning_system_id($connection, $groupDetails->group_id);
        return SubscriberValidator::preCheckSubscriberPasswordPolicy(
            $connection,
            $subscriberPassword,
            $provSystemID,
            $groupDetails
        );
    }

    /**
     * Print log for update parameters. Masked it if they are set in updateParams variable.
     *
     * @param array $updateParams
     *
     * @return void
     */
    private function _printLogForUpdateParams($updateParams)
    {
        // TODO: In future move this to utility method for more generic use.
        if (isset($updateParams['voicemail_pin'])) {
            $updateParams['voicemail_pin'] = CommonConstant::PIN_MASK;
        }
        if (isset($updateParams['user_password'])) {
            $updateParams['user_password'] = CommonConstant::PIN_MASK;
        }
    }

    /**
     * Is Voicemail PIN Visiblity Permitted.
     *
	 * @param int $groupId
	 *
     * @return bool
     */
    private function _isVoicemailPINVisiblityPermitted($groupId)
    {
		return IS_VISIBLE_VOICEMAIL_PIN &&
		!(in_array($groupId, DISABLE_VISIBILITY_VOICEMAIL_PIN_FOR_CUSTOMER)) &&
		(
            count(
                array_intersect(
                    [PermissionConstant::OPERATIONS_PERMISSION, PermissionConstant::ROOT_PERMISSION],
                    CommonHelper::getPresentationValue('permissions')
                )
            ) > 0
        );
    }

    /**
     * Call recording role assignment
     *
     * @param PDO $connection
     * @param string $serviceSetValue
     * @param int $callRecordingUserID
     * @param int $provSystemID
     *
     * @return void
     *
     * @throws Exception
     */
    private function _callRecordingRoleAssignment($connection, $serviceSetValue, $callRecordingUserID, $provSystemID)
    {
        $role = UtilityMethods::isLiveSupportSupervisorServiceBundle($serviceSetValue)
            ? CallRecordingConstant::ROLE_SUPERVISORS
            : CallRecordingConstant::ROLE_USERS;
        $roleID = CallRecordingRoleDao::getRoleIDByName($connection, $role);

        $callRecordingRoleDetails = [
            'call_recording_user_id' => $callRecordingUserID,
            'call_recording_role_id' => $roleID
        ];

        $existingRoleID = CallRecordingRoleDao::getRoleIDByCallRecordingUserID(
            $connection,
            $callRecordingUserID
        );

        if ($existingRoleID != $roleID) {
            // prov
            $orecxProv = new Orecx();
            $orecxProv->associateUsersToRole(
                $connection,
                $provSystemID,
                $callRecordingRoleDetails
            );
            // db
            CallRecordingRoleDao::setUserRole($connection, $callRecordingUserID, $roleID);
        }
    }

    /**
     * Calculate role assocation rules
     *
     * @param string $oldServiceSet
     * @param string $newServiceSet
     *
     * @return bool
     */
    private function _calculateAssociationRules($oldServiceSet, $newServiceSet)
    {
        $ruleCallRecToLSCallRec = UtilityMethods::isCallRecordingServiceBundleWithoutLS($oldServiceSet)
            && UtilityMethods::isLiveSupportCallRecordingServiceBundle($newServiceSet);

        $ruleLSRoleChange = UtilityMethods::isLiveSupportCallRecordingServiceBundle($oldServiceSet)
            && UtilityMethods::isLiveSupportCallRecordingServiceBundle($newServiceSet);

        return $ruleCallRecToLSCallRec || $ruleLSRoleChange;
    }

    /**
     * Calculate role dissocation rules
     *
     * @param string $oldServiceSet
     * @param string $newServiceSet
     *
     * @return bool
     */
    private function _calculateDissociationRules($oldServiceSet, $newServiceSet)
    {
        return UtilityMethods::isCallRecordingServiceBundleWithoutLS($newServiceSet)
            && UtilityMethods::isLiveSupportCallRecordingServiceBundle($oldServiceSet);
    }

    /**
     * Method to create missing CIM group and member of this group
     *
     * @param PDO $connection
     * @param object $groupDetails
     * @param array $subscriberDetails
     * @param string $servers
     *
     * @return bool|array
     * @throws Exception
     */
    public function createMissingCIMGroupAndMember($connection, $groupDetails, $subscriberDetails, $servers)
    {
        $this->_info('There is no group on CIM to be created subscriber in with this ID: '
            . $groupDetails->cim_group_identifier . '  The missing group is being created...');

        $individualProv = new models\external\prov\Individual();
        $provSystemId = $this->get_first_member_provisioning_system_id($connection, $groupDetails->group_id);

        $createOrgParam = [];
        $createOrgParam['prov_system_id'] = $provSystemId;

        $parentGroupDetails = GroupDao::get_group_details_for_update($connection, $groupDetails->parent_group_id);

        if (UtilityMethods::isOrganization($groupDetails->group_type)) {
            $createOrgParam['vm_switch']= $groupDetails->vm_switch;
            $createOrgParam['vm_notification_address'] = UtilityMethods::isEmpty($groupDetails->vm_notification_address)
                ? $parentGroupDetails->vm_notification_address
                : $groupDetails->vm_notification_address;
        } else {
            $createOrgParam['domain'] = 'anything';
            $createOrgParam['vm_switch'] = $parentGroupDetails->vm_switch;
            $createOrgParam['vm_notification_address'] = $parentGroupDetails->vm_notification_address;
        }

        // Creating missing group
        $orgResponse = $individualProv->CreateOrgRequest1($connection, $groupDetails, $createOrgParam);
        if (UtilityMethods::isNotEqual($orgResponse[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
            $this->_error('CreateOrgRequest1 failed. Unable to create group on CIM.');
            return $this->_build_error_message(ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED, $orgResponse);
        }

        // Adding the subscriber after the missing group is created
        $cimResponse = $individualProv->createRichMessagingAccount($connection, $groupDetails, $subscriberDetails, $servers);
        if (UtilityMethods::isNotEqual($cimResponse[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
            $this->_error('createRichMessagingAccount failed. Unable to create subscriber on CIM.');
            return $this->_build_error_message(ApiResponseConstant::SUBSCRIBER_ADD_USER_CALL_FAILED, $cimResponse);
        }

        $this->_debug('Missing CIM group (' . $groupDetails->cim_group_identifier . ') and member ('
            . $subscriberDetails["user_id"] . ') is created.');

        return true;
    }

    /**
     * Method to set IPL for Intercom service
     *
     * @param PDO $connection
     * @param string $topLevelDomain
     * @param array $subscriberDetails
     *
     * @return void
     */
    public function setIPLForIntercom($connection, $topLevelDomain, $subscriberDetails)
    {
        $individualProv = new models\external\prov\Individual();
        $a2Response = $individualProv->setIPL($connection, $topLevelDomain, $subscriberDetails);
        if (UtilityMethods::isNotEqual($a2Response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
            $this->_error(" Subscriber Facade -> setIPL failed for user " . $subscriberDetails["user_id"]
                . "  Response is " . $a2Response[ProvisioningConstant::A2_RESPONSE]);
            $this->_info(" If the subscriber is created successfully, please take an action on A2 to set IPL");
        }
    }

    /**
     * Get Security Group Names from call_recording_role table
     *
     * @return array
     * @throws Exception
     */
    public function getSecurityGroupNames()
    {
        try {
            $securityRoles = CallRecordingDao::getSecurityGroupNames(DbConnector::getConnection());
            foreach ($securityRoles as $key => $securityRole) {
                if ($securityRole['name'] == CallRecordingConstant::ROLE_ADMINSTRATORS) {
                    unset($securityRoles[$key]);
                }
            }
            return $securityRoles;
        } catch (Exception $e) {
            $this->_error('getSecurityGroupNames failed!', $e);
            return ['ERROR_CODE' => ApiResponseConstant::GET_SECURITY_GROUP_NAME];
        }
    }

    /**
     * Get Organizational Group Names from Orecx
     *
     * @param int $groupID
     *
     * @return array
     * @throws Exception
     */
    public function getOrganizationalGroupNames($groupID)
    {
        try {
            $provSystemID = $this->get_provisioning_system_id(DbConnector::getConnection(), $groupID);
            $orecxProv = new models\external\prov\Orecx();
            $orecxGroupID = $orecxProv->getOrecxGroupID(DbConnector::getConnection(), $groupID);
            if (!empty($orecxGroupID) && UtilityMethods::isNotNull($orecxGroupID['orecx_group_id'])) {
                $organizationalGroups = $orecxProv->getChildOrganizationalGroups(
                    DbConnector::getConnection(),
                    $provSystemID,
                    $orecxGroupID['orecx_group_id']
                );
                return $organizationalGroups;
            } else {
                return ['ERROR_CODE' => ApiResponseConstant::GET_ORGANIZATIONAL_GROUP_NAME];
            }
        } catch (Exception $e) {
            $this->_error('getPsxRoutingLabelByNodeType failed!', $e);
            return ['ERROR_CODE' => ApiResponseConstant::GET_ORGANIZATIONAL_GROUP_NAME];
        }
    }

    /**
     * Update MS Teams Subscriber
     *
     * @param $connection
     * @param $oldSubscriberDetails
     * @param $subscriberDetails
     * @param $groupDetails
     * @return array|bool
     * @throws Exception
     */
    private function updateMsTeamsMenuBundle($connection, $oldSubscriberDetails, $subscriberDetails, $groupDetails)
    {
        $msTeamsCarrier = MsTeamsCarrierDao::getCarrierByGroupId($connection, $subscriberDetails);
        $subscriberDetails['ms_teams_carrier_id'] = $msTeamsCarrier['ms_teams_carrier_id'];
        $validatorResponse = SubscriberValidator::preProcessMsTeamsDetails(
            $connection,
            $subscriberDetails,
            $groupDetails,
            $oldSubscriberDetails
        );
        if (is_array($validatorResponse)) {
            return $validatorResponse;
        }

        $provisioningMSTeamsSubscriber = new ProvisioningMSTeamsSubscriber(
            $connection,
            $groupDetails,
            $subscriberDetails
        );
        $response = $provisioningMSTeamsSubscriber->updateMsTeamsSubscriber($oldSubscriberDetails);
        if (is_array($response)) {
            return $response;
        }
        SubscriberAddressDao::updateBySubscriberId($connection, $subscriberDetails);
        return true;
    }

    /**
     * Control Keycloak Subscriber Information
     *
     * @param array $subscriberDetails
     * @param object $groupDetails
     *
     * @return array
     * @throws Exception
     */
    public function syncKeycloakSubscriber($subscriberDetails, $groupDetails)
    {
        $connection = DbConnector::getConnection();
        $ssoFacade = new SsoFacade();
        $keycloakSubscriberResponse = $ssoFacade->getSyncKeycloakUser($connection, $groupDetails, $subscriberDetails, SsoConstant::SUBSCRIBER_SSO);

        return $keycloakSubscriberResponse;
    }

    /**
     * Handle Subscriber CTBS data
     *
     * @param $subscriberCTBS
     * @return string
     *
     */
    private function _handleSubscriberCTBS($subscriberCTBS)
    {
        $callType = "disabled";
        if (is_array($subscriberCTBS)) {
            if ($subscriberCTBS['international']) {
                $callType = "international";
                if (
                    $subscriberCTBS['longDistance']
                    || $subscriberCTBS['longDistanceInterRateArea']
                    || $subscriberCTBS['longDistanceIntraRateArea']
                ) {
                    $callType = "all";
                }
            } else {
                if (
                    $subscriberCTBS['longDistance']
                    || $subscriberCTBS['longDistanceInterRateArea']
                    || $subscriberCTBS['longDistanceIntraRateArea']
                ) {
                    $callType = "long_distance";
                }
            }
        }

        return $callType;
    }

    /**
     * Generate ctbs call type array for subscriber
     *
     * @param string $scheduleCallRestriction
     * @return array
     */
    private function _generateCTBSArrayForSubscriber(string $scheduleCallRestriction)
    {
        if ($scheduleCallRestriction == 'international') {
            $ctbsCallTypes = [
                'international' => true,
                'internationalExcludingHC' => false,
                'local' => false,
                'longDistance' => false,
                'longDistanceInterRateArea' => false,
                'longDistanceIntraRateArea' => false,
                'premium' => false
            ];
        } elseif ($scheduleCallRestriction == 'long_distance') {
            $ctbsCallTypes = [
                'international' => false,
                'internationalExcludingHC' => false,
                'local' => false,
                'longDistance' => true,
                'longDistanceInterRateArea' => true,
                'longDistanceIntraRateArea' => true,
                'premium' => false
            ];
        } elseif ($scheduleCallRestriction == 'all') {
            $ctbsCallTypes = [
                'international' => true,
                'internationalExcludingHC' => false,
                'local' => true,
                'longDistance' => true,
                'longDistanceInterRateArea' => true,
                'longDistanceIntraRateArea' => true,
                'premium' => true
            ];
        } else {
            $ctbsCallTypes = [
                'international' => false,
                'internationalExcludingHC' => false,
                'local' => false,
                'longDistance' => false,
                'longDistanceInterRateArea' => false,
                'longDistanceIntraRateArea' => false,
                'premium' => false
            ];
        }

        return $ctbsCallTypes;
    }

     /**
      * Method to update subscriber CLI on A2 if group, site and subscriber uses Mega Domain.
     *
     * @param PDO $connection
     * @param object $groupDetails
     * @param array $subscriberDetails
     * @param array $siteDetails
     * @param bool $defaultMode
     *
     * @return array|void
     * @throws Exception
     */
    public function updateDefaultDomainSubscriberCLI($connection, $groupDetails, $subscriberDetails, $siteDetails, $defaultMode = false)
    {
        try {
            $subscriberDetails['sitePublicNumber'] = null;
            $subscriberDetails["domain"] = $groupDetails->top_level_domain;
            // We are dealing with SMBs, so sesm name never changes
            unset($siteDetails['sesm_name']);
            $individualProv = new models\external\prov\Individual();

            if ($defaultMode) {
                $siteDetails['subdomain_name'] = CommonConstant::DEFAULT_MODE_SITE_NAME
                                                    . "." . CommonConstant::DEFAULT_MODE_SMB_NAME
                                                    . "." . $groupDetails->top_level_domain;
                $subscriberDetails['sitePublicNumber'] = empty($siteDetails['public_number']) ? $subscriberDetails["public_charge_id"] : $siteDetails['public_number'];
            } else {
                $subscriberDetails['is_default_subdomain_subscriber'] = TransitionConstant::DEFAULT_MODE_DISABLED;
                // Site change
                $response = $individualProv->modifyUserSubdomain($connection, $groupDetails, $subscriberDetails, $siteDetails);
                if (preg_match("/Failed to move single user. Source domain and target domain should not be same/", $response[ProvisioningConstant::A2_RESPONSE])) {
                    $this->_debug("updateDefaultDomainSubscriberCLI -> The subscriber has already been moved to the traditional domain.");
                } elseif (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                    $this->_error("updateDefaultDomainSubscriberCLI-modifyUserSubdomain failed, the response is: "
                        . $response[ProvisioningConstant::A2_RESPONSE]);
                    return false;
                }

                $this->updateSubscriberPasswordAfterSiteMove($connection, (array)$groupDetails, $subscriberDetails);

                $isSiteUpdate = true;
            }

            // First name and last name change
            $response = $individualProv->modifyUser(
                $connection,
                $groupDetails,
                $subscriberDetails,
                $siteDetails,
                false
            );

            if ($defaultMode && !empty($siteDetails['public_number'])) {
                $nationalFormatSPN = UtilityMethods::replaceIfStartsWith(
                    $subscriberDetails['sitePublicNumber'],
                    CommonConstant::DEFAULT_MODE_ETISALAT_E164_PREFIX,
                    CommonConstant::DEFAULT_MODE_SITE_PN_PREFIX
                );
                $subscriberDetails["voip_numbers"][] = $nationalFormatSPN;
            }

            $removeDNandNQResponse = $individualProv->removeDNandNQforUser1($connection, $groupDetails, $subscriberDetails);
            $removeDirectoryNumberResponse = $individualProv->removeUserDirectoryNumber1($connection, $groupDetails, $subscriberDetails);
            $setUserDirectoryNumberResponse = $individualProv->setUserDirectoryNumber1($connection, $groupDetails, $subscriberDetails, true);

            if ($nationalFormatSPN) {
                $setDNandNQResponse = $individualProv->setDNandNQforDefaultUser1($connection, $groupDetails, $subscriberDetails, $nationalFormatSPN);
            }

            if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                $this->_error("updateDefaultDomainSubscriberCLI-modifyUser failed, the response is: "
                    . $response [ProvisioningConstant::A2_RESPONSE]);

                // Rollback for site move
                if (isset($isSiteUpdate)) {
                    $siteDetails['subdomain_name'] = CommonConstant::DEFAULT_MODE_SITE_NAME
                                                        . "." . CommonConstant::DEFAULT_MODE_SMB_NAME
                                                        . "." . $groupDetails->top_level_domain;
                    $response = $individualProv->modifyUserSubdomain($connection, $groupDetails, $subscriberDetails, $siteDetails);
                    if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                        $this->_error("Rollback - updateDefaultDomainSubscriberCLI-modifyUserSubdomain failed, the response is: "
                            . $response[ProvisioningConstant::A2_RESPONSE]);
                    }
                }

                return false;
            }

            // Public charge id change
            if (!empty($subscriberDetails['sitePublicNumber']) || !empty($subscriberDetails['public_charge_id'])) {
                $response = $individualProv->setUserChargeInfo1($connection, $groupDetails, $subscriberDetails);
            } elseif (
                !empty($siteDetails['public_number'])
                || (
                    isset($siteDetails['old_public_number'])
                    && !empty($siteDetails['old_public_number'])
                )
            ) {
                // [ACL-54824]: was removing the UserCharInfo but its strongly advised not to remove them
                // so we've commented out the calls for removeUserChargeInfo1
                // $response = $individualProv->removeUserChargeInfo1($connection, $groupDetails, $subscriberDetails);
            }

            // Common rollback for public charge id change
            if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                $this->_error("updateDefaultDomainSubscriberCLI-setUserChargeInfo1 failed, the response is: "
                    . $response[ProvisioningConstant::A2_RESPONSE]);

                // Rollback for site move
                if (isset($isSiteUpdate)) {
                    $siteDetails['subdomain_name'] = CommonConstant::DEFAULT_MODE_SITE_NAME
                                                        . "." . CommonConstant::DEFAULT_MODE_SMB_NAME
                                                        . "." . $groupDetails->top_level_domain;
                    $response = $individualProv->modifyUserSubdomain($connection, $groupDetails, $subscriberDetails, $siteDetails);
                    if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                        $this->_error("Rollback - updateDefaultDomainSubscriberCLI-modifyUserSubdomain failed, the response is: "
                            . $response[ProvisioningConstant::A2_RESPONSE]);
                    }
                }

                // Rollback for first name and last name change
                $subscriberDetails['is_default_subdomain_subscriber'] = TransitionConstant::DEFAULT_MODE_ENABLED;
                $siteDetails['public_name'] = $siteDetails['old_public_name'] ?? $siteDetails['public_name'];
                $response = $individualProv->modifyUser(
                    $connection,
                    $groupDetails,
                    $subscriberDetails,
                    $siteDetails,
                    false
                );
                if (UtilityMethods::isNotEqual($response[ProvisioningConstant::A2_RESPONSE], CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                    $this->_error("Rollback - updateDefaultDomainSubscriberCLI-modifyUser failed, the response is: "
                        . $response[ProvisioningConstant::A2_RESPONSE]);
                }

                return false;
            }

            return true;
        } catch (Exception $e) {
            $this->_error("Exception caught in updateDefaultDomainSubscriberCLI!", $e);
            return false;
        }
    }

    /**
     * Sends an email as a notification for new Subscribers
     *
     * @param object $groupDetails
     * @param array $subscriberDetails
     *
     * @return bool
     */
    public function sendWelcomeEmailNotification($groupDetails, $subscriberDetails)
    {
        //Don't send email when et11 feature is disabled.
        if(!SUBSCRIBER_WELCOME_EMAIL_NOTIFICATION) return;

        $connection = DbConnector::getConnection();
        $subscriberAllDetails = SubscriberDao::get_subscriber_details_by_user_id($connection, $subscriberDetails['user_id'], $subscriberDetails['group_id']);
        $subscriberAllDetails['auth_token'] = UtilityMethods::getUserAuthToken($subscriberAllDetails['subscriber_id'], $subscriberAllDetails['group_identifier']);
        $userLanguage = strtoupper($subscriberAllDetails['language']);
        if ($userLanguage !== GroupConstant::LANGUAGE_PREFERENCE_FR) {
            $userLanguage = GroupConstant::LANGUAGE_PREFERENCE_EN;
        }
        $tokenExist = SubscriberDao::get_password_recovery_details_by_user_id($connection, $subscriberAllDetails['user_id']);
        if ($tokenExist) {
            $subscriberAllDetails['is_expired'] = "0";
            SubscriberDao::update_password_recovery_details($connection, $subscriberAllDetails, $subscriberAllDetails['subscriber_id']);
        } else {
            SubscriberDao::insert_password_recovery($connection, $subscriberAllDetails);
        }
        $welcomeMailContent = file_get_contents(
            EMAIL_TEMPLATE_PATH. constant("EmailTemplateConstant::EUP_WELCOME_" . $userLanguage));
        $welcomeHeader = constant("SubscriberConstant::SUBSCRIBER_WELCOME_HEADER_TEXT_" . $userLanguage);
        $findVariableTemplate = [
            '/{{NAME}}/',
            '/{{USER_ID}}/',
            '/{{EUP_URL}}/'
        ];
        $passwordLink = SsoConstant::EUP_ROOT_URL . SubscriberConstant::FORGET_PASSWORD_URL . $subscriberAllDetails['auth_token'];
        $replaceVariable = [
            $subscriberDetails['first_name'],
            $subscriberDetails ['user_id'],
            $passwordLink
        ];
        $welcomeMailBody = preg_replace($findVariableTemplate, $replaceVariable, $welcomeMailContent);
        $to = $subscriberDetails['email'];
        $connection = DbConnector::getConnection();
        $subject = $welcomeHeader . " " . $subscriberAllDetails['first_name'] . " " . $subscriberAllDetails["last_name"];
        $from = GroupDao::get_self_notification_emailid($connection, $groupDetails->group_id) ??
            GroupDao::get_parent_notification_emailid($connection, $groupDetails->group_id);

        return UtilityMethods::sendEmail($to, $subject, $welcomeMailBody, $from);
    }

    /**
     * If initReset and/or PreventPrevionsPassword is set to true on the top_level_domain
     * A2 requires subscriber to change its password after subscriber move operations from one site to another
     *
     * Remedy: after site movement if we update the passwords automatically, subscriber will not be affected
     *
     * @param PDO $connection
     * @param array $groupDetails
     * @param array $subscriberDetails
     *
     * @return bool
     */
    public function updateSubscriberPasswordAfterSiteMove($connection, $groupDetails, $subscriberDetails)
    {
        $this->_debug(
            'Subscriber Facade -> updateSubscriberPasswordAfterSiteMove started for subscriber: ' . $subscriberDetails['user_id']
        );

        $domain = new models\external\prov\Domain();
        $domainInfoA2 = $domain->get_root_domain($connection, $groupDetails);
        if (isset($domainInfoA2['passwordPolicy']['name'])) {
            $passwordPolicy = $domain->get_password_policy(
                $connection,
                $groupDetails,
                $domainInfoA2['passwordPolicy']['name']
            );
            if ($passwordPolicy['initReset'] == 1 || $passwordPolicy['initReset'] == CommonConstant::API_PARAM_VALUE_TRUE) {
                $pa = new Pa();

                if ($passwordPolicy['preventPreviousPassword'] == 1 || $passwordPolicy['preventPreviousPassword'] == CommonConstant::API_PARAM_VALUE_TRUE) {
                    $dummyPassword = $this->_generate_password($connection, $groupDetails['top_level_domain'], $groupDetails['prov_system_id'])['password'];
                    $parameter = ["password" => $dummyPassword];
                    $response = $pa->changePassword($connection, $subscriberDetails, $parameter);
                    if (UtilityMethods::isEqual($response, CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                        $this->_debug('Subscriber Facade -> updateSubscriberPasswordAfterSiteMove '
                            . $subscriberDetails['user_id'] . ' password updated to dummy password.');
                    }
                }

                $parameter = ["password" => $subscriberDetails['user_password']];
                $response = $pa->changePassword($connection, $subscriberDetails, $parameter);
                if (UtilityMethods::isEqual($response, CommonConstant::PROVISIONING_SUCCESS_MSG)) {
                    $this->_debug('Subscriber Facade -> updateSubscriberPasswordAfterSiteMove '
                        . $subscriberDetails['user_id'] . ' password updated back to original password.');
                }
            }
        }
        return true;
    }

}
//end of class SubscriberFacade