My-Commerce_core 1.0.0

data/lib/product_filters.rb

@@ -0,0 +1,179 @@
+# THIS FILE SHOULD BE OVER-RIDDEN IN YOUR SITE EXTENSION!
+#   the exact code probably won't be useful, though you're welcome to modify and reuse
+#   the current contents are mainly for testing and documentation
+
+# set up some basic filters for use with products
+#
+# Each filter has two parts
+#  * a parametrized named scope which expects a list of labels
+#  * an object which describes/defines the filter
+#
+# The filter description has three components
+#  * a name, for displaying on pages
+#  * a named scope which will 'execute' the filter
+#  * a mapping of presentation labels to the relevant condition (in the context of the named scope)
+#  * an optional list of labels and values (for use with object selection - see taxons examples below)
+#
+# The named scopes here have a suffix '_any', following SearchLogic's convention for a
+# scope which returns results which match any of the inputs. This is purely a convention,
+# but might be a useful reminder.
+#
+# When creating a form, the name of the checkbox group for a filter F should be
+# the name of F's scope with [] appended, eg "price_range_any[]", and for
+# each label you should have a checkbox with the label as its value. On submission,
+# Rails will send the action a hash containing (among other things) an array named
+# after the scope whose values are the active labels.
+#
+# SearchLogic will then convert this array to a call to the named scope with the array
+# contents, and the named scope will build a query with the disjunction of the conditions
+# relating to the labels, all relative to the scope's context.
+#
+# The details of how/when filters are used is a detail for specific models (eg products
+# or taxons), eg see the taxon model/controller.
+
+# See specific filters below for concrete examples.
+
+# This module is included by Taxon. In development mode that inclusion does not
+# happen until Taxon class is loaded. Ensure that Taxon class is loaded before
+# you try something like Product.price_range_any
+module ProductFilters
+
+  # Example: filtering by price
+  #   The named scope just maps incoming labels onto their conditions, and builds the conjunction
+  #   'price' is in the base scope's context (ie, "select foo from products where ...") so
+  #     we can access the field right away
+  #   The filter identifies which scope to use, then sets the conditions for each price range
+  #
+  # If user checks off three different price ranges then the argument passed to
+  # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
+  #
+  Product.scope :price_range_any,
+    lambda {|*opts|
+      conds = opts.map {|o| ProductFilters.price_filter[:conds][o]}.reject {|c| c.nil?}
+      Product.scoped(:joins => :master).conditions_any(conds)
+    }
+
+  def ProductFilters.price_filter
+    conds = [ [ "Under $10",    "price             <= 10" ],
+              [ "$10 - $15",    "price between 10 and 15" ],
+              [ "$15 - $18",    "price between 15 and 18" ],
+              [ "$18 - $20",    "price between 18 and 20" ],
+              [ "$20 or over",  "price             >= 20" ] ]
+    { :name   => "Price Range",
+      :scope  => :price_range_any,
+      :conds  => Hash[*conds.flatten],
+      :labels => conds.map {|k,v| [k,k]}
+    }
+  end
+
+
+  # Example: filtering by possible brands
+  #
+  # First, we define the scope. Two interesting points here: (a) we run our conditions
+  #   in the scope where the info for the 'brand' property has been loaded; and (b)
+  #   because we may want to filter by other properties too, we give this part of the
+  #   query a unique name (which must be used in the associated conditions too).
+  #
+  # Secondly, the filter. Instead of a static list of values, we pull out all existing
+  #   brands from the db, and then build conditions which test for string equality on
+  #   the (uniquely named) field "p_brand.value". There's also a test for brand info
+  #   being blank: note that this relies on with_property doing a left outer join
+  #   rather than an inner join.
+
+  if Property.table_exists? && @@brand_property = Property.find_by_name("brand")
+    Product.scope :brand_any,
+      lambda {|*opts|
+        conds = opts.map {|o| ProductFilters.brand_filter[:conds][o]}.reject {|c| c.nil?}
+        Product.with_property("brand").conditions_any(conds)
+      }
+
+    def ProductFilters.brand_filter
+      brands = ProductProperty.where(:property_id => @@brand_property).map(&:value).compact.uniq
+      conds  = Hash[*brands.map {|b| [b, "product_properties.value = '#{b}'"]}.flatten]
+      { :name   => "Brands",
+        :scope  => :brand_any,
+        :conds  => conds,
+        :labels => (brands.sort).map {|k| [k,k]}
+      }
+    end
+  end
+
+  # Example: a parametrized filter
+  #   The filter above may show brands which aren't applicable to the current taxon,
+  #   so this one only shows the brands that are relevant to a particular taxon and
+  #   its descendants.
+  #
+  #   We don't have to give a new scope since the conditions here are a subset of the
+  #   more general filter, so decoding will still work - as long as the filters on a
+  #   page all have unique names (ie, you can't use the two brand filters together
+  #   if they use the same scope). To be safe, the code uses a copy of the scope.
+  #
+  #   HOWEVER: what happens if we want a more precise scope?  we can't pass
+  #   parametrized scope names to SearchLogic, only atomic names, so couldn't ask
+  #   for taxon T's customized filter to be used. BUT: we can arrange for the form
+  #   to pass back a hash instead of an array, where the key acts as the (taxon)
+  #   parameter and value is its label array, and then get a modified named scope
+  #   to get its conditions from a particular filter.
+  #
+  #   The brand-finding code can be simplified if a few more named scopes were added to
+  #   the product properties model.
+
+  if Property.table_exists? && @@brand_property
+    Product.scope :selective_brand_any, lambda {|opts| Product.brand_any(opts) }
+
+    def ProductFilters.selective_brand_filter(taxon = nil)
+      if taxon.nil?
+        taxon = Taxonomy.first.root
+      end
+      all_brands = ProductProperty.where(:property_id => @@brand_property).map(&:value).uniq
+      scope = ProductProperty.scoped(:conditions => ["property_id = ?", @@brand_property]).
+                              scoped(:joins      => {:product => :taxons},
+                                     :conditions => ["taxons.id in (?)", [taxon] + taxon.descendants])
+      brands = scope.map {|p| p.value}
+
+      { :name   => "Applicable Brands",
+        :scope  => :selective_brand_any,
+        :conds  => Hash[*all_brands.map {|m| [m, "p_colour.value like '%#{m}%'"]}.flatten],
+        :labels => brands.sort.map {|k| [k,k]}
+      }
+    end
+  end
+
+
+  # Provide filtering on the immediate children of a taxon
+  #
+  # This doesn't fit the pattern of the examples above, so there's a few changes.
+  # Firstly, it uses an existing scope which was not built for filtering - and so
+  # has no need of a conditions mapping, and secondly, it has a mapping of name
+  # to the argument type expected by the other scope.
+  #
+  # This technique is useful for filtering on objects (by passing ids) or with a
+  # scope that can be used directly (eg. testing only ever on a single property).
+  #
+  # This scope selects products in any of the active taxons or their children.
+  #
+  def ProductFilters.taxons_below(taxon)
+    return ProductFilters.all_taxons if taxon.nil?
+    { :name   => "Taxons under " + taxon.name,
+      :scope  => :taxons_id_in_tree_any,
+      :labels => taxon.children.sort_by(&:position).map {|t| [t.name, t.id]},
+      :conds  => nil
+    }
+  end
+
+  # Filtering by the list of all taxons
+  #
+  # Similar idea as above, but we don't want the descendants' products, hence
+  # it uses one of the auto-generated scopes from SearchLogic.
+  #
+  # idea: expand the format to allow nesting of labels?
+  def ProductFilters.all_taxons
+    taxons = Taxonomy.all.map {|t| [t.root] + t.root.descendants }.flatten
+    { :name   => "All taxons",
+      :scope  => :taxons_id_equals_any,
+      :labels => taxons.sort_by(&:name).map {|t| [t.name, t.id]},
+      :conds  => nil	# not needed
+    }
+  end
+
+end

data/lib/redirect_legacy_product_url.rb

@@ -0,0 +1,13 @@
+class RedirectLegacyProductUrl
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if env["PATH_INFO"] =~ %r{/t/.+/p/(.+)}
+      return [301, {'Location'=> "/products/#{$1}" }, []]
+    end
+    @app.call(env)
+  end
+
+end

data/lib/scopes/dynamic.rb

@@ -0,0 +1,31 @@
+# This module is extended by ProductScope
+module Scopes::Dynamic
+  module_function
+
+  # Sample dynamic scope generating from set of products
+  # generates 0 or (2..scope_limit) scopes for prices, based
+  # on number of products (uses Math.log, to guess number of scopes)
+  def price_scopes_for(products, scope_limit=5)
+    scopes = []
+
+    # Price based scopes
+    all_prices = products.map(&:price).sort
+
+    ranges = [Math.log(products.length).floor, scope_limit].max
+
+    if ranges >= 2
+      l = all_prices.length / ranges
+      scopes << ProductScope.new({:name => "master_price_lte", :arguments => [all_prices[l]] })
+
+      (ranges - 2).times do |x|
+        scopes << ProductScope.new({:name => "price_between",
+                                    :arguments => [ all_prices[l*(x+1)+1], all_prices[l*(x+2)] ] })
+      end
+
+      scopes << ProductScope.new({:name => "master_price_gte", :arguments => [all_prices[l*(ranges-1)+1]] })
+    end
+
+    scopes
+  end
+
+end

data/lib/scopes/product.rb

@@ -0,0 +1,266 @@
+module Scopes::Product
+  #TODO: change this to array pairs so we preserve order?
+
+  SCOPES = {
+    # Scopes for selecting products based on taxon
+    :taxon => {
+      :taxons_name_eq => [:taxon_name],
+      :in_taxons => [:taxon_names],
+    },
+    # product selection based on name, or search
+    :search => {
+      :in_name => [:words],
+      :in_name_or_keywords => [:words],
+      :in_name_or_description => [:words],
+      :with_ids => [:ids]
+    },
+    # Scopes for selecting products based on option types and properties
+    :values => {
+      :with => [:value],
+      :with_property => [:property],
+      :with_property_value => [:property, :value],
+      :with_option => [:option],
+      :with_option_value => [:option, :value],
+    },
+    # product selection based upon master price
+    :price => {
+      :price_between => [:low, :high],
+      :master_price_lte => [:amount],
+      :master_price_gte => [:amount],
+    },
+  }
+
+  ORDERING = [
+    :ascend_by_updated_at,
+    :descend_by_updated_at,
+    :ascend_by_name,
+    :descend_by_name,
+    :ascend_by_master_price,
+    :descend_by_master_price,
+    :descend_by_popularity,
+  ]
+
+  ORDERING.each do |name|
+    next if %w(asecend_by_master_price descend_by_master_price).include?(name.to_s)
+    r = name.to_s.match(/(.*)_by_(.*)/)
+
+    order_text = "products.#{r[2]} "
+    order_text << ((r[1] == 'ascend') ?  "asc" : "desc")
+
+    Product.send(:scope, name.to_s, Product.send(:relation).order(order_text) )
+  end
+
+  ::Product.scope :ascend_by_master_price, Product.joins(:variants_with_only_master).order('variants.price asc')
+
+  ::Product.scope :descend_by_master_price, Product.joins(:variants_with_only_master).order('variants.price desc')
+
+  ATTRIBUTE_HELPER_METHODS = {
+    :with_ids => :product_picker_field
+  }
+
+  # Ryan Bates - http://railscasts.com/episodes/112
+  # general merging of conditions, names following the searchlogic pattern
+  ::Product.scope :conditions, lambda { |*args| {:conditions => args}}
+
+  # conditions_all is a more descriptively named enhancement of the above
+  ::Product.scope :conditions_all, lambda { |*args| {:conditions => [args].flatten}}
+
+  # forming the disjunction of a list of conditions (as strings)
+  ::Product.scope :conditions_any, lambda { |*args|
+    args = [args].flatten
+    raise "non-strings in conditions_any" unless args.all? {|s| s.is_a? String}
+    {:conditions => args.map {|c| "(#{c})"}.join(" OR ")}
+  }
+
+
+  ::Product.scope :price_between, lambda { |low, high|
+    { :joins => :master, :conditions => ["variants.price BETWEEN ? AND ?", low, high] }
+  }
+
+  ::Product.scope :master_price_lte, lambda { |price|
+    { :joins => :master, :conditions => ["variants.price <= ?", price] }
+  }
+
+  ::Product.scope :master_price_gte, lambda { |price|
+    { :joins => :master, :conditions => ["variants.price >= ?", price] }
+  }
+
+
+  # This scope selects products in taxon AND all its descendants
+  # If you need products only within one taxon use
+  #
+  #   Product.taxons_id_eq(x)
+  #
+  ::Product.scope :in_taxon, lambda {|taxon|
+    { :joins => :taxons, :conditions => ["taxons.id IN (?) ", taxon.self_and_descendants.map(&:id)]}
+  }
+
+  # This scope selects products in all taxons AND all its descendants
+  # If you need products only within one taxon use
+  #
+  #   Product.taxons_id_eq([x,y])
+  #
+  Product.scope :in_taxons, lambda {|*taxons|
+    taxons = get_taxons(taxons)
+    taxons.first ? prepare_taxon_conditions(taxons) : {}
+  }
+
+  # for quick access to products in a group, WITHOUT using the association mechanism
+  Product.scope :in_cached_group, lambda {|product_group|
+    { :joins => "JOIN product_groups_products ON products.id = product_groups_products.product_id",
+      :conditions => ["product_groups_products.product_group_id = ?", product_group]
+    }
+  }
+
+
+  # a scope that finds all products having property specified by name, object or id
+  Product.scope :with_property, lambda {|property|
+    conditions = case property
+    when String   then ["properties.name = ?", property]
+    when Property then ["properties.id = ?", property.id]
+    else               ["properties.id = ?", property.to_i]
+    end
+
+    {
+      :joins => :properties,
+      :conditions => conditions
+    }
+  }
+
+  # a scope that finds all products having an option_type specified by name, object or id
+  Product.scope :with_option, lambda {|option|
+    conditions = case option
+    when String     then ["option_types.name = ?", option]
+    when OptionType then ["option_types.id = ?",   option.id]
+    else                 ["option_types.id = ?",   option.to_i]
+    end
+
+    {
+      :joins => :option_types,
+      :conditions => conditions
+    }
+  }
+
+  # a simple test for product with a certain property-value pairing
+  # note that it can test for properties with NULL values, but not for absent values
+  Product.scope :with_property_value, lambda { |property, value|
+    conditions = case property
+    when String   then ["properties.name = ?", property]
+    when Property then ["properties.id = ?", property.id]
+    else               ["properties.id = ?", property.to_i]
+    end
+    conditions = ["product_properties.value = ? AND #{conditions[0]}", value, conditions[1]]
+
+    {
+      :joins => :properties,
+      :conditions => conditions
+    }
+  }
+
+  # a scope that finds all products having an option value specified by name, object or id
+  Product.scope :with_option_value, lambda {|option, value|
+    option_type_id = case option
+    when String
+      option_type = OptionType.find_by_name(option) || option.to_i
+    when OptionType
+      option.id
+    else
+      option.to_i
+    end
+    conditions = [
+      "option_values.name = ? AND option_values.option_type_id = ?",
+      value, option_type_id
+    ]
+
+    {
+      :joins => {:variants => :option_values},
+      :conditions => conditions
+    }
+  }
+
+  # finds product having option value OR product_property
+  Product.scope :with, lambda{|value|
+    {
+      :conditions => ["option_values.name = ? OR product_properties.value = ?", value, value],
+      :joins => {:variants => :option_values, :product_properties => []}
+    }
+  }
+
+  Product.scope :in_name, lambda{|words|
+    Product.like_any([:name], prepare_words(words))
+  }
+
+  Product.scope :in_name_or_keywords, lambda{|words|
+    Product.like_any([:name, :meta_keywords], prepare_words(words))
+  }
+
+  Product.scope :in_name_or_description, lambda{|words|
+    Product.like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
+  }
+
+  Product.scope :with_ids, lambda{|ids|
+    ids = ids.split(',') if ids.is_a?(String)
+    { :conditions => {:id => ids} }
+  }
+
+  # Sorts products from most popular (poularity is extracted from how many
+  # times use has put product in cart, not completed orders)
+  #
+  # there is alternative faster and more elegant solution, it has small drawback though,
+  # it doesn stack with other scopes :/
+  #
+  # :joins => "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
+  # :order => 'COALESCE(cnt, 0) DESC'
+  Product.scope :descend_by_popularity,
+    {
+      :joins => :master,
+      :order => <<SQL
+         COALESCE((
+           SELECT
+             COUNT(line_items.id)
+           FROM
+             line_items
+           JOIN
+             variants as popular_variants
+           ON
+             popular_variants.id = line_items.variant_id
+           WHERE
+             popular_variants.product_id = products.id
+         ), 0) DESC
+SQL
+    }
+
+  # Produce an array of keywords for use in scopes.
+  # Always return array with at least an empty string to avoid SQL errors
+  def self.prepare_words(words)
+    return [''] if words.blank?
+    a = words.split(/[,\s]/).map(&:strip)
+    a.any? ? a : ['']
+  end
+
+  def self.arguments_for_scope_name(name)
+    if group = Scopes::Product::SCOPES.detect{|k,v| v[name.to_sym]}
+      group[1][name.to_sym]
+    end
+  end
+
+  def self.get_taxons(*ids_or_records_or_names)
+    ids_or_records_or_names.flatten.map { |t|
+      case t
+      when Integer then Taxon.find_by_id(t)
+      when ActiveRecord::Base then t
+      when String
+        Taxon.find_by_name(t) ||
+        Taxon.find(:first, :conditions => [
+          "taxons.permalink LIKE ? OR taxons.permalink = ?", "%/#{t}/", "#{t}/"
+        ])
+      end
+    }.compact.uniq
+  end
+
+  # specifically avoid having an order for taxon search (conflicts with main order)
+  def self.prepare_taxon_conditions(taxons)
+    ids = taxons.map{|taxon| taxon.self_and_descendants.map(&:id)}.flatten.uniq
+    { :joins => :taxons, :conditions => ["taxons.id IN (?)", ids] }
+  end
+end

data/lib/scopes/variant.rb

@@ -0,0 +1,18 @@
+module Scopes::Variant
+
+  #FIXME WARNING tested only under sqlite and postgresql
+  Variant.scope :descend_by_popularity, lambda{
+      order('COALESCE((SELECT COUNT(*) FROM  line_items GROUP BY line_items.variant_id HAVING line_items.variant_id = variants.id), 0) DESC')
+  }
+
+  # for selecting variants with an option value
+  # no option type given since the value implies an option type
+  # this scope can be chained repeatedly, since the join name is unique
+  Variant.scope :has_option, lambda {|opt|
+    tbl = 'o' + Time.now.to_i.to_s + Time.now.usec.to_s
+    { :joins => "inner join option_values_variants as #{tbl} on variants.id = #{tbl}.variant_id",
+      :conditions => ["#{tbl}.option_value_id = (?)", opt]
+    }
+  }
+
+end

data/lib/scopes.rb

@@ -0,0 +1,69 @@
+# This module contains all custom scopes created for selecting products.
+#
+# All usable scopes *should* be included in SCOPES constant, it represents
+# all scopes that are selectable from user interface, extensions can extend
+# and modify it, but should provide corresponding translations.
+#
+# Format of constant is following:
+#
+#   {
+#     :namespace/grouping => {
+#       :name_of_the_scope => [:list, :of, :arguments]
+#     }
+#   }
+#
+#   This values are used in translation file, to describe them in the interface.
+#   So for each scope you define here you have to provide following entry in translation file
+#   product_scopes:
+#     name_of_the_group:
+#       name: Translated name of the group
+#       description: Longer description of what this scope group does, inluding
+#         any possible help user may need
+#       scopes:
+#         name_of_the_scope:
+#           name: Short name of the scope
+#           description: What does this scope does exactly
+#           arguments:
+#             arg1: Description of argument
+#             arg2: Description of second Argument
+#
+module Scopes
+  module_function
+
+  def generate_translation(all_scopes)
+    result = {"groups" => {}, "scopes" => {}}
+    all_scopes.dup.each_pair do |group_name, scopes|
+      result["groups"][group_name.to_s] = {
+        'name' => group_name.to_s.humanize,
+        'description' => "Scopes for selecting products based on #{group_name.to_s}",
+      }
+
+      scopes.each_pair do |scope_name, targs|
+        hashed_args = {}
+        targs.each{|v| hashed_args[v.to_s] = v.to_s.humanize}
+
+        result['scopes'][scope_name.to_s] = {
+          'name' => scope_name.to_s.humanize,
+          'description' => "",
+          'args' => hashed_args.dup
+        }
+      end
+    end
+
+    result
+  end
+
+  def generate_translations
+    require 'ya2yaml'
+    {
+      'product_scopes' => generate_translation(Scopes::Product::SCOPES)
+    }.ya2yaml
+  end
+end
+
+# Rails 3 TODO
+# ActiveRecord::NamedScope::Scope.class_eval do
+#   def to_sql
+#     construct_finder_sql({})
+#   end
+# end

data/lib/spree/calculated_adjustments.rb

@@ -0,0 +1,69 @@
+module Spree::CalculatedAdjustments
+  module ClassMethods
+    def calculated_adjustments(options = {})
+      has_one   :calculator, :as => :calculable, :dependent => :destroy
+      accepts_nested_attributes_for :calculator
+      validates :calculator, :presence => true if options[:require]
+
+      class_attribute :calculators
+      self.calculators = Set.new
+      # @available_calculators = []
+      def register_calculator(calculator)
+        self.calculators.add(calculator)
+      end
+      # def calculators
+      #   @available_calculators
+      # end
+
+      if options[:default]
+        default_calculator_class = options[:default]
+        #if default_calculator_class.available?(self.new)
+          before_create :default_calculator
+          define_method(:default_calculator) do
+            self.calculator ||= default_calculator_class.new
+          end
+        # else
+        #   raise(ArgumentError, "calculator #{default_calculator_class} can't be used with #{self}")
+        # end
+      else
+        define_method(:default_calculator) do
+          nil
+        end
+      end
+
+      include InstanceMethods
+    end
+  end
+
+  module InstanceMethods
+    def calculator_type
+      calculator.class.to_s if calculator
+    end
+
+    def calculator_type=(calculator_type)
+      clazz = calculator_type.constantize if calculator_type
+      self.calculator = clazz.new if clazz and not self.calculator.is_a? clazz
+    end
+
+    # Creates a new adjustment for the target object (which is any class that has_many :adjustments) and
+    # sets amount based on the calculator as applied to the calculable argument (Order, LineItems[], Shipment, etc.)
+    # By default the adjustment will not be considered mandatory
+    def create_adjustment(label, target, calculable, mandatory=false)
+      amount = self.calculator.compute(calculable)
+      target.adjustments.create(:amount => amount,  :source => calculable,
+                                                    :originator => self,
+                                                    :label => label,
+                                                    :mandatory => mandatory)
+    end
+
+    # Updates the amount of the adjustment using our Calculator and calling the +compute+ method with the +calculable+
+    # referenced passed to the method.
+    def update_adjustment(adjustment, calculable)
+      adjustment.update_attribute_without_callbacks(:amount, self.calculator.compute(calculable))
+    end
+  end
+
+  def self.included(receiver)
+    receiver.extend Spree::CalculatedAdjustments::ClassMethods
+  end
+end

data/lib/spree/config.rb

@@ -0,0 +1,33 @@
+module Spree
+  # Singleton class to access the configuration object (AppConfiguration.first by default) and its preferences.
+  #
+  # Usage:
+  #   Spree::Config[:foo]                  # Returns the +foo+ preference
+  #   Spree::Config[]                      # Returns a Hash with all the application preferences
+  #   Spree::Config.instance               # Returns the configuration object (AppConfiguration.first)
+  #   Spree::Config.set(preferences_hash)  # Set the application preferences as especified in +preference_hash+
+  #   Spree::Config.searcher/searcher=     # get/set the default product search implementation
+  class Config
+    include Singleton
+    include Spree::PreferenceAccess
+
+    class << self
+      def instance
+        return @configuration if @configuration
+        return nil unless ActiveRecord::Base.connection.tables.include?('configurations')
+        @configuration ||= AppConfiguration.find_or_create_by_name("Default configuration")
+        @configuration
+      end
+
+      # searcher_class allows spree extension writers to provide their own Search class
+      def searcher_class
+        @searcher_class ||= Spree::Search::Base
+      end
+
+      def searcher_class=(sclass)
+        @searcher_class = sclass
+      end
+
+    end
+  end
+end