vwo-fme-ruby-sdk 1.0.0 → 1.2.0

data/lib/vwo/utils/url_util.rb

@@ -0,0 +1,46 @@
+# Copyright 2025 Wingify Software Pvt. Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require_relative '../services/settings_service'
+
+class UrlUtil
+  @collection_prefix = nil
+
+  class << self
+    attr_accessor :collection_prefix
+
+    # Initializes the UrlUtil with an optional collection prefix.
+    #
+    # @param collection_prefix [String] Optional prefix for URL collections.
+    # @return [UrlUtil] The singleton instance of UrlUtil with updated properties.
+    def init(collection_prefix: nil)
+      @collection_prefix = collection_prefix if collection_prefix.is_a?(String)
+      self
+    end
+
+    # Retrieves the base URL.
+    #
+    # @return [String] The base URL.
+    def get_base_url
+      base_url = SettingsService.instance.hostname
+
+      return base_url if SettingsService.instance.is_gateway_service_provided
+
+      # Construct URL with collection_prefix if it exists
+      return "#{base_url}/#{@collection_prefix}" if @collection_prefix
+
+      base_url
+    end
+  end
+end

data/lib/vwo/utils/uuid_util.rb

@@ -0,0 +1,55 @@
+# Copyright 2025 Wingify Software Pvt. Ltd.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'uuidtools'
+require 'securerandom'
+
+SEED_URL = 'https://vwo.com' # Replace with actual SEED_URL
+
+class UUIDUtil
+  # Generates a random UUID based on an API key.
+  #
+  # @param sdk_key [String] The API key used to generate a namespace for the UUID.
+  # @return [String] A random UUID string.
+  def self.get_random_uuid(sdk_key)
+    namespace = UUIDTools::UUID.sha1_create(UUIDTools::UUID_DNS_NAMESPACE, sdk_key)
+    random_uuid = UUIDTools::UUID.sha1_create(namespace, SecureRandom.uuid)
+    random_uuid.to_s
+  end
+
+  # Generates a UUID for a user based on their user_id and account_id.
+  #
+  # @param user_id [String] The user's ID.
+  # @param account_id [String] The account ID associated with the user.
+  # @return [String] A UUID string formatted without dashes and in uppercase.
+  def self.get_uuid(user_id, account_id)
+    vwo_namespace = UUIDTools::UUID.sha1_create(UUIDTools::UUID_URL_NAMESPACE, SEED_URL)
+    user_id_namespace = generate_uuid(account_id, vwo_namespace)
+    uuid_for_user_id_account_id = generate_uuid(user_id, user_id_namespace)
+
+    uuid_for_user_id_account_id.to_s.delete('-').upcase
+  end
+
+  # Helper function to generate a UUID v5 based on a name and a namespace.
+  #
+  # @param name [String] The name from which to generate the UUID.
+  # @param namespace [UUIDTools::UUID] The namespace used to generate the UUID.
+  # @return [UUIDTools::UUID] A UUID string or nil if inputs are invalid.
+  def self.generate_uuid(name, namespace)
+    return nil if name.nil? || namespace.nil?
+    # Convert name to string to handle integer inputs
+    name_str = name.to_s
+    UUIDTools::UUID.sha1_create(namespace, name_str)
+  end
+end

data/lib/vwo/vwo_builder.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Wingify Software Pvt. Ltd.
+# Copyright 2025 Wingify Software Pvt. Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,18 +12,163 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require_relative 'constants'
-require_relative 'utils/request'  # Include your request utilities
+# require 'json'
+# require 'uri'
+require_relative './enums/log_level_enum'
+require_relative 'vwo_client'
+require_relative './services/settings_service'
+require_relative './packages/storage/storage'
+require_relative './packages/network_layer/manager/network_manager'
+require_relative './packages/segmentation_evaluator/core/segmentation_manager'
+require_relative './services/logger_service'
 
-module VWO
-  class VWOBuilder
-    def initialize(options)
-      @options = options
+class VWOBuilder
+  attr_reader :settings, :storage, :log_manager, :is_settings_fetch_in_progress, :vwo_instance
+
+  # Initialize the VWOBuilder with the given options
+  # @param options [Hash] The options for the VWOBuilder
+  def initialize(options)
+    @options = options
+    @settings = nil
+    @storage = nil
+    @log_manager = nil
+    @is_settings_fetch_in_progress = false
+    @vwo_instance = nil
+  end
+
+  # Set the network manager
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_network_manager
+    begin
+      network_instance = NetworkManager.instance(@options[:threading] || {})
+      network_instance.attach_client(@options[:network][:client]) if @options[:network] && @options[:network][:client]
+      LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Network Layer"})
+      network_instance.get_config.set_development_mode(@options[:is_development_mode]) if @options[:is_development_mode]
+      self
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "Failed to initialize network manager: #{e.message}", nil)
+      self
+    end
+  end
+
+  # Set the segmentation manager
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_segmentation
+    SegmentationManager.instance.attach_evaluator(@options[:segmentation]) if @options[:segmentation]
+    LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Segmentation Evaluator"})
+    self
+  end
+
+  # Fetch the settings from the server
+  # @param force [Boolean] Whether to force the fetch of settings
+  # @return [Hash] The settings
+  def fetch_settings(force = false)
+    return @settings if !force && @settings
+    
+    @is_settings_fetch_in_progress = true
+    settings = SettingsService.new(@options).get_settings(force)
+    @is_settings_fetch_in_progress = false
+    @settings = settings unless force
+    settings
+  end
+
+  # Get the settings from the server
+  # @param force [Boolean] Whether to force the fetch of settings
+  # @return [Hash] The settings
+  def get_settings(force = false)
+    return @settings if !force && @settings
+    
+    begin
+      fetch_settings(force)
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "Failed to fetch settings: #{e.message}", nil)
+      {}
+    end
+  end
+
+  # Set the storage
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_storage
+    @storage = @options[:storage] ? Storage.instance.attach_connector(@options[:storage]) : nil
+    LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Storage"})
+    self
+  end
+
+  # Set the settings service
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_settings_service
+    @settings_service = SettingsService.new(@options)
+    self
+  end
+
+  # Set the logger
+  # @return [VWOBuilder] The VWOBuilder instance
+  def set_logger
+    begin
+      @log_manager = LoggerService.new(@options[:logger] || {})
+      LoggerService.log(LogLevelEnum::DEBUG, "SERVICE_INITIALIZED", {service: "Logger"})
+    rescue => e
+      puts "Got error while setting logger: #{e.message}"
+    end
+    self
+  end
+
+  # Initialize the polling
+  # @return [VWOBuilder] The VWOBuilder instance
+  def init_polling
+    return self unless @options[:poll_interval]
+
+    unless @options[:poll_interval].is_a?(Numeric)
+      LoggerService.log(LogLevelEnum::ERROR, "INIT_OPTIONS_INVALID", {
+        key: 'poll_interval',
+        correctType: 'number'
+      })
+      return self
     end
 
-    # Initializes the HTTP client for VWOBuilder
-    def init_client
-      Utils::Request.set_base_url(@options[:gateway_service_url] || Constants::HTTPS_PROTOCOL + Constants::BASE_URL)
+    # Check if the polling interval is greater than or equal to 1000
+    unless @options[:poll_interval] >= 1000
+      LoggerService.log(LogLevelEnum::ERROR, "INIT_OPTIONS_INVALID", {
+        key: 'poll_interval',
+        correctType: 'number'
+      })
+      return self
+    end
+
+    check_and_poll
+    self
+  end
+
+  # Build the VWO instance
+  # @param settings [Hash] The settings for the VWO instance
+  # @return [VWOClient] The VWO instance
+  def build(settings)
+    @vwo_instance = VWOClient.new(settings, @options)
+    @vwo_instance
+  end
+
+  # This method is used to check and poll the settings from the server
+  # @return [VWOBuilder] The VWOBuilder instance
+  def check_and_poll
+    polling_interval = @options[:poll_interval]
+
+    @thread_pool = NetworkManager.instance.get_client.get_thread_pool
+    @thread_pool.post do
+      loop do
+        sleep(polling_interval / 1000.0)
+        begin
+          latest_settings = fetch_settings(true)
+          if latest_settings.to_json != @settings.to_json
+            @settings = latest_settings
+            LoggerService.log(LogLevelEnum::INFO, "POLLING_SET_SETTINGS")
+            @vwo_instance.update_settings(latest_settings.clone, false) if @vwo_instance
+          else
+            LoggerService.log(LogLevelEnum::INFO, "POLLING_NO_CHANGE_IN_SETTINGS")
+          end
+        rescue StandardError => e
+          LoggerService.log(LogLevelEnum::ERROR, "POLLING_FETCH_SETTINGS_FAILED")
+        end
+      end
     end
   end
-end
+end

data/lib/vwo/vwo_client.rb

@@ -1,4 +1,4 @@
-# Copyright 2024 Wingify Software Pvt. Ltd.
+# Copyright 2025 Wingify Software Pvt. Ltd.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -12,131 +12,181 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'json'
-require_relative 'utils/logger_helper'
-require_relative 'constants'
-require_relative 'utils/request'
-require_relative 'utils/feature_flag_response'
-
-module VWO
-  # VWOClient class provides methods to interact with the VWO feature flag system,
-  # including retrieving feature flags, tracking events, and setting attributes.
-  class VWOClient
-    # Makes the `options` instance variable private and only accessible within the class.
-    private attr_reader :options
-
-    # Initializes a new instance of the VWOClient.
-    #
-    # @param [Hash] options Configuration options like account_id and sdk_key.
-    def initialize(options)
-      @options = options
+require_relative 'services/settings_service'
+require_relative 'models/user/context_model'
+require_relative 'api/get_flag'
+require_relative 'api/set_attribute'
+require_relative 'api/track_event'
+require_relative 'utils/url_util'
+require_relative 'utils/settings_util'
+require_relative 'services/logger_service'
+require_relative 'enums/log_level_enum'
+require_relative 'utils/network_util'
+require_relative 'models/schemas/settings_schema_validation'
+
+class VWOClient
+  attr_accessor :settings, :original_settings
+  attr_reader :options
+
+  def initialize(settings, options)
+    @options = options
+    @settings = settings
+    @original_settings = settings.dup
+    
+    begin
+      set_settings_and_add_campaigns_to_rules(settings, self)
+      UrlUtil.init(collection_prefix: @settings.get_collection_prefix)
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "Error setting and adding campaigns to rules message: #{e.message}", nil)
     end
+    LoggerService.log(LogLevelEnum::INFO, "CLIENT_INITIALIZED")
+    self
+  end
 
-    # Fetches a feature flag for a given feature_key and context.
-    #
-    # @param [String] feature_key The unique identifier for the feature flag.
-    # @param [Hash] context The context data, which must include a `:id` for user identification.
-    #
-    # @return [FeatureFlagResponse] Returns a FeatureFlagResponse with the status of the feature flag and any associated variables.
-    #         Returns `isEnabled: false` and empty variables if any error occurs.
-    #
-    # @raise [StandardError] Raises an error if `feature_key`, `context`, or `userId` are missing or invalid.
-    def get_flag(feature_key, context)
-      # Raise an error if the SDK is not initialized with options.
-      raise 'VWO is not initialized' if @options.nil?
-
-      # Validate that feature_key and context are present, and userId is in context.
-      raise 'feature_key is required to get the feature flag' if feature_key.nil? || feature_key.empty?
-      raise 'context is required to get the feature flag' if context.nil?
-      raise 'userId is required for flag evaluation, please provide id in context' if context[:id].nil? || context[:id].empty?
-
-      # Add the feature key to the context.
-      context['featureKey'] = feature_key
-
-      # Construct the API endpoint for getting the feature flag.
-      endpoint = "#{Constants::ENDPOINT_GET_FLAG}?accountId=#{@options[:account_id]}&sdkKey=#{@options[:sdk_key]}"
-
-      # Send a POST request to retrieve the feature flag.
-      response = Utils::Request.send_post_request(endpoint, context)
-
-      # If a response is received, parse it and return a FeatureFlagResponse.
-      if response
-        parsed_response = JSON.parse(response)
-        return FeatureFlagResponse.new(parsed_response['isEnabled'], parsed_response['variables'])
-      else
-        # Return a default disabled response if no response was received.
-        return FeatureFlagResponse.new(false, [])
+  # Get the flag for a given feature key and context
+  # @param feature_key [String] The key of the feature to get the flag for
+  # @param context [Hash] The context of the user
+  # @return [GetFlagResponse] The flag for the given feature key and context
+  def get_flag(feature_key, context)
+    api_name = 'get_flag'
+    error_response = GetFlagResponse.new(false, [])
+  
+    begin
+      hooks_service = HooksService.new(@options)
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+
+      unless feature_key.is_a?(String) && !feature_key.empty?
+        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'feature_key', type: feature_key.class.name , correctType: 'String'})
+        raise TypeError, 'feature_key should be a non-empty string'
+      end
+      unless SettingsSchema.new.is_settings_valid(@original_settings)
+        LoggerService.log(LogLevelEnum::ERROR, "API_SETTING_INVALID")
+        raise TypeError, 'Invalid Settings'
+      end
+      unless context.is_a?(Hash)
+        LoggerService.log(LogLevelEnum::ERROR, "API_CONTEXT_INVALID")
+        raise TypeError, 'Invalid context'
       end
+      unless context[:id].is_a?(String) && !context[:id].empty?
+        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'context.id', type: context[:id].class.name, correctType: 'String'})
+        raise TypeError, 'Invalid context, id should be a non-empty string'
+      end
+      
+      context_model = ContextModel.new.model_from_dictionary(context)
+      FlagApi.new.get(feature_key, @settings, context_model, hooks_service)
     rescue StandardError => e
-      # Log the error and return a default FeatureFlagResponse with `isEnabled: false`.
-      LoggerHelper.logger.error("Error in get_flag: #{e.message}")
-      return FeatureFlagResponse.new(false, [])
+      LoggerService.log(LogLevelEnum::ERROR, "API_THROW_ERROR", {apiName: api_name, err: e.message})
+      error_response
     end
+  end
 
-    # Tracks an event for a given event_name and context.
-    #
-    # @param [String] event_name The name of the event to track.
-    # @param [Hash] context The context data, which must include a `:id` for user identification.
-    # @param [Hash] event_properties Optional properties related to the event.
-    #
-    # @return [String, nil] The response from the server, or nil if an error occurred.
-    #
-    # @raise [StandardError] Raises an error if `event_name`, `context`, or `userId` are missing or invalid.
-    def track_event(event_name, context, event_properties = {})
-      # Raise an error if the SDK is not initialized with options.
-      raise 'VWO is not initialized' if @options.nil?
-
-      # Validate that event_name and userId in context are present.
-      raise 'event_name is required to track the event' if event_name.nil? || event_name.empty?
-      raise 'userId is required to track the event, please provide id in context' if context.nil? || context[:id].nil? || context[:id].empty?
-
-      # Add event details to the context.
-      context['eventName'] = event_name
-      context['eventProperties'] = event_properties
-
-      # Construct the API endpoint for tracking the event.
-      endpoint = "#{Constants::ENDPOINT_TRACK_EVENT}?accountId=#{@options[:account_id]}&sdkKey=#{@options[:sdk_key]}"
-
-      # Send a POST request to track the event.
-      response = Utils::Request.send_post_request(endpoint, context)
-
-      # Return the server response.
-      response
+  # Track an event with given properties and context
+  # @param event_name [String] The name of the event to track
+  # @param context [Hash] The context of the user
+  # @param event_properties [Hash] The properties of the event
+  # @return [Hash] The result of the event tracking
+  def track_event(event_name, context, event_properties = {})
+    api_name = 'track_event'
+    
+    begin
+      hooks_service = HooksService.new(@options)
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+      
+      unless event_name.is_a?(String) && !event_name.empty?
+        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'event_name', type: event_name.class.name, correctType: 'String'})
+        raise TypeError, 'event_name should be a non-empty string'
+      end
+      unless event_properties.is_a?(Hash)
+        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'event_properties', type: event_properties.class.name, correctType: 'Hash'})
+        raise TypeError, 'event_properties should be a hash'
+      end
+      unless SettingsSchema.new.is_settings_valid(@original_settings)
+        LoggerService.log(LogLevelEnum::ERROR, "API_SETTING_INVALID")
+        raise TypeError, 'Invalid Settings'
+      end
+      unless context[:id].is_a?(String) && !context[:id].empty?
+        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'context.id', type: context[:id].class.name, correctType: 'String'})
+        raise TypeError, 'Invalid context, id should be a non-empty string'
+      end
+      
+      context_model = ContextModel.new.model_from_dictionary(context)
+      TrackApi.new.track(@settings, event_name, context_model, event_properties, hooks_service)
     rescue StandardError => e
-      # Log the error if any occurs during event tracking.
-      LoggerHelper.logger.error("Error tracking event: #{e.message}")
+      LoggerService.log(LogLevelEnum::ERROR, "API_THROW_ERROR", {apiName: api_name, err: e.message})
+      { event_name: false }
     end
+  end
 
-    # Sets an attribute for a given user context.
-    #
-    # @param [String] attribute_key The key of the attribute to set.
-    # @param [String] attribute_value The value of the attribute to set.
-    # @param [Hash] context The context data, which must include a `:id` for user identification.
-    #
-    # @return [String, nil] The response from the server, or nil if an error occurred.
-    #
-    # @raise [StandardError] Raises an error if `attribute_key`, `attribute_value`, or `userId` are missing or invalid.
-    def set_attribute(attribute_key, attribute_value, context)
-      # Raise an error if the SDK is not initialized with options.
-      raise 'VWO is not initialized' if @options.nil?
-
-      # Validate that attribute_key, attribute_value, and userId in context are present.
-      raise 'attribute_key is required for set_attribute' if attribute_key.nil? || attribute_key.empty?
-      raise 'attribute_value is required for set_attribute' if attribute_value.nil?
-      raise 'userId is required to set attribute, please provide id in context' if context.nil? || context[:id].nil? || context[:id].empty?
+  # Set attributes for a given context
+  # @param attributes [Hash] The attributes to set
+  # @param context [Hash] The context of the user
+  # @return [Hash] The result of the attribute setting
+  def set_attribute(attributes, context = nil)
+    api_name = 'set_attribute'
+    
+    begin
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+
+      unless attributes.is_a?(Hash) && !attributes.empty?
+        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'attributes', type: attributes.class.name, correctType: 'Hash'})
+        raise TypeError, 'Attributes should be a hash with key-value pairs and non-empty'
+      end
+      unless context.is_a?(Hash)
+        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'context', type: context.class.name, correctType: 'Hash'})
+        raise TypeError, 'Invalid context'
+      end
+      unless context[:id].is_a?(String) && !context[:id].empty?
+        LoggerService.log(LogLevelEnum::ERROR, "API_INVALID_PARAM", {apiName: api_name, key: 'context.id', type: context[:id].class.name, correctType: 'String'})
+        raise TypeError, 'Invalid context, id should be a non-empty string'
+      end
+      unless SettingsSchema.new.is_settings_valid(@original_settings)
+        LoggerService.log(LogLevelEnum::ERROR, "API_SETTING_INVALID")
+        raise TypeError, 'Invalid Settings'
+      end
+      
+      context_model = ContextModel.new.model_from_dictionary(context)
+      SetAttributeApi.new.set_attribute(@settings, attributes, context_model)
+    rescue StandardError => e
+      LoggerService.log(LogLevelEnum::ERROR, "API_THROW_ERROR", {apiName: api_name, err: e.message})
+    end
+  end
 
-      # Add the attribute details to the context.
-      context['attributeKey'] = attribute_key
-      context['attributeValue'] = attribute_value
+  # Update the settings of the VWO client instance
+  # @param settings [Hash] The settings to update with (optional)
+  # @param is_via_webhook [Boolean] Whether the update is via webhook (default: true)
+  # @return [void]
+  def update_settings(settings = nil, is_via_webhook = true)
+    api_name = 'update_settings'
+    
+    begin
+      LoggerService.log(LogLevelEnum::DEBUG, "API_CALLED", {apiName: api_name})
+      
+      # Fetch settings from server or use provided settings if not empty
+      settings_to_update = if settings.nil? || settings.empty?
+        SettingsService.instance.fetch_settings(is_via_webhook)
+      else
+        settings
+      end
 
-      # Construct the API endpoint for setting the attribute.
-      endpoint = "#{Constants::ENDPOINT_SET_ATTRIBUTE}?accountId=#{@options[:account_id]}&sdkKey=#{@options[:sdk_key]}"
+      # Validate settings schema
+      unless SettingsSchema.new.is_settings_valid(settings_to_update)
+        LoggerService.log(LogLevelEnum::ERROR, "API_SETTING_INVALID")
+        raise TypeError, 'Invalid Settings'
+      end
 
-      # Send a POST request to set the attribute.
-      Utils::Request.send_post_request(endpoint, context)
+      # Set the settings on the client instance
+      set_settings_and_add_campaigns_to_rules(settings_to_update, self)
+      LoggerService.log(LogLevelEnum::INFO, "SETTINGS_UPDATED", {apiName: api_name, isViaWebhook: is_via_webhook})
     rescue StandardError => e
-      # Log the error if any occurs during setting the attribute.
-      LoggerHelper.logger.error("Error setting attribute: #{e.message}")
+      LoggerService.log(
+        LogLevelEnum::ERROR,
+        "SETTINGS_FETCH_FAILED",
+        {
+          apiName: api_name,
+          isViaWebhook: is_via_webhook,
+          err: e.message
+        }
+      )
     end
   end
 end