kete_translatable_content 0.1.0

data/lib/kete_translatable_content/extensions/helpers/extended_fields_helper.rb

@@ -0,0 +1,17 @@
+# we only override specific extended field uses for translation
+# rather than overriding find
+ExtendedFieldsHelper.module_eval do
+  def label_show_column(extended_field)
+    translated_label = extended_field.label_translation_for(I18n.locale) || extended_field.label
+    h(translated_label)
+  end
+
+  def example_show_column(extended_field)
+    translated_example = extended_field.example_translation_for(I18n.locale) || extended_field.example
+    h(translated_example)
+  end
+
+  def extended_field_example(extended_field)
+    example_show_column(extended_field)
+  end
+end

data/lib/kete_translatable_content/extensions/helpers/search_helper.rb

@@ -0,0 +1,5 @@
+SearchHelper.module_eval do
+  def tag_show_link_options(tag)
+    { :title => t('search_helper.tag_show_link_options.title_with_translations', :tag_name => tag.name) }
+  end
+end

data/lib/kete_translatable_content/extensions/helpers/translations_helper.rb

@@ -0,0 +1,72 @@
+TranslationsHelper.module_eval do
+  def modify_translation_value(value, original_object)
+    if original_object.class == ConfigurableSetting
+      YAML.load(value)
+    else
+      value
+    end
+  end
+
+  def localized_label_for(attribute_key)
+    @localized_labels ||= Hash.new
+    return @localized_labels[attribute_key] if @localized_labels[attribute_key].present?
+
+    extended_content_keys = nil
+    if @original.respond_to?('extended_content_pairs')
+      extended_content_keys = @original.extended_content_pairs.collect { |p| p[0] }
+    end
+
+    if extended_content_keys &&
+        (extended_content_keys.include?(attribute_key.to_s) ||
+         extended_content_keys.include?(attribute_key.to_s + '_multiple'))
+
+      ef = ExtendedField.find(:first,
+                              :conditions => ExtendedField.clauses_for_has_label_that_matches(attribute_key))
+
+      @localized_labels[attribute_key] = display_label_for(ef)
+    else
+      form_key = '.' + 'form' + '.'
+      
+      if ITEM_CLASSES.include?(@translatable_class.name)
+        form_key = 'topics' + form_key
+      else
+        form_key = @translatable_class.name.tableize + form_key
+      end
+
+      @localized_labels[attribute_key] = t(form_key + attribute_key.to_s)
+    end
+
+    @localized_labels[attribute_key]
+  end
+
+    %w{untranslated translated}.each do |term|
+    name = term + '_values_with_localized_labels'
+    define_method(name) do
+      set_original
+      raise "No object supplied to translate." if @original.blank?
+      raise "No matching translation available." if term == 'translated' && @translation.blank?
+
+      existing_value = instance_variable_get('@' + name)
+      return existing_value if existing_value.present?
+
+      new_value = @original.translatable_attributes.collect do |attribute_key|
+        attribute_key = check_for_value_hash(attribute_key)
+        value = (term == 'untranslated') ? @original.send(attribute_key) : @translation[attribute_key]
+        { :attribute_key => attribute_key,
+          :localized_label => localized_label_for(attribute_key),
+          :value => modify_translation_value(value, @original) }
+      end
+
+      instance_variable_set('@' + name, new_value)
+    end
+  end
+
+  def check_for_value_hash(value)
+    if  value.is_a?(Hash) && value.keys.include?('value') && value.keys.include?('label')
+      value["label"]
+    else
+      value
+    end
+  end
+
+end

data/lib/kete_translatable_content/extensions/models/audio_recording.rb

@@ -0,0 +1,12 @@
+# extensions to the kete audio recording model
+
+# instantiate the model in Kete before reopening it below
+AudioRecording
+
+require File.join(File.dirname(__FILE__), '../tagging_overrides')
+require File.join(File.dirname(__FILE__), '../oai_dc_helpers_overrides')
+
+class AudioRecording
+  include TaggingOverrides
+  include OaiDcHelpersOverrides
+end

data/lib/kete_translatable_content/extensions/models/basket.rb

@@ -0,0 +1,34 @@
+# extensions to the kete basket model
+
+# require the model in Kete before reopening it below
+Basket
+
+class Basket
+  def self.list_as_names_and_urlified_names
+    basket_list = Array.new
+    all(:select => 'id, name, urlified_name, locale, original_locale').each do |basket|
+      translated_name = basket.name_translation_for(I18n.locale) || basket.name
+      basket_list << [translated_name, basket.urlified_name]
+    end
+    basket_list
+  end
+
+  def additional_footer_content_with_inheritance
+    value = parsed_value_from(self._configurable_settings.find_by_name('additional_footer_content'))
+    value ||= parsed_value_from(self.site_basket._configurable_settings.find_by_name('additional_footer_content'))
+    value
+  end
+
+  private
+
+  def parsed_value_from(setting)
+    if setting
+      # Original translation values will come back as YAML, but translations are just strings
+      value = (setting.original_locale == setting.locale) ? YAML.load(setting.value) : setting.value
+      # If the value is blank, return nil, else return the value
+      value.to_s.squish.present? ? value : nil
+    else
+      nil
+    end
+  end
+end

data/lib/kete_translatable_content/extensions/models/comment.rb

@@ -0,0 +1,12 @@
+# extensions to the kete comment model
+
+# require the model in Kete before reopening it below
+Comment
+
+require File.join(File.dirname(__FILE__), '../tagging_overrides')
+require File.join(File.dirname(__FILE__), '../oai_dc_helpers_overrides')
+
+class Comment
+  include TaggingOverrides
+  include OaiDcHelpersOverrides
+end

data/lib/kete_translatable_content/extensions/models/document.rb

@@ -0,0 +1,12 @@
+# extensions to the kete document model
+
+# require the model in Kete before reopening it below
+Document
+
+require File.join(File.dirname(__FILE__), '../tagging_overrides')
+require File.join(File.dirname(__FILE__), '../oai_dc_helpers_overrides')
+
+class Document
+  include TaggingOverrides
+  include OaiDcHelpersOverrides
+end

data/lib/kete_translatable_content/extensions/models/still_image.rb

@@ -0,0 +1,12 @@
+# extensions to the kete still image model
+
+# require the model in Kete before reopening it below
+StillImage
+
+require File.join(File.dirname(__FILE__), '../tagging_overrides')
+require File.join(File.dirname(__FILE__), '../oai_dc_helpers_overrides')
+
+class StillImage
+  include TaggingOverrides
+  include OaiDcHelpersOverrides
+end

data/lib/kete_translatable_content/extensions/models/system_setting.rb

@@ -0,0 +1,13 @@
+# convenience methods for setting translatable system settings
+
+# require the model in Kete before reopening it below
+SystemSetting
+
+class SystemSetting
+  def self.update_translatables
+    Kete.translatable_system_settings.each { |name| SystemSetting.find_by_name(name).make_translatable }
+  end
+  def make_translatable
+    update_attributes!(:takes_translations => true)
+  end
+end

data/lib/kete_translatable_content/extensions/models/tag.rb

@@ -0,0 +1,37 @@
+# extensions to the kete tag model
+
+# require the model in Kete before reopening it below
+Tag
+
+class Tag
+  # When creating a tag, check both the tags model, and tag translations
+  # This is done so that for each tag we don't end up with additiona Tag
+  # objects, but rather, the original tag object with multiple translations
+  #
+  # Example Usage:
+  #
+  # >> I18n.locale = :en
+  # >> t = Tag.find_or_create_with_like_by_name('Welcome')
+  # => #<Tag id: 1, name: "Welcome", locale: "en", original_locale: "en">
+  # >> t.translate(:name => 'Accueil', :locale => :fr)
+  # => #<Tag::Translation name: "Accueil", tag_id: 1, _id: ObjectID('4bfb1a87f42ce12372000002'), locale: "fr", translatable_locale: "en">
+  #
+  # >> I18n.locale = :fr
+  # >> Tag.find_or_create_with_like_by_name('Accueil')
+  # => #<Tag id: 1, name: "Accueil", locale: "fr", original_locale: "en">
+
+  # redefine so if no tag is found initially, we look for translations too
+  # this method is used by acts-as-taggable-on for all creations of tags
+  def self.find_or_create_with_like_by_name(name)
+    # first, see if any tags exist with this name
+    existing_tag = first(:conditions => ["name LIKE ?", name])
+
+    # if no tag exists, look through tag translations for the current locale
+    if !existing_tag && existing_tag = Tag::Translation.first(:name => name, :locale => I18n.locale)
+      # if a translation is found, return the original Tag object, but with the values of the locale
+      existing_tag = Tag.swap_in_translation_for_single(existing_tag.translatable)
+    end
+
+    existing_tag || create(:name => name, :locale => I18n.locale)
+  end
+end

data/lib/kete_translatable_content/extensions/models/topic.rb

@@ -0,0 +1,12 @@
+# extensions to the kete topic model
+
+# require the model in Kete before reopening it below
+Topic
+
+require File.join(File.dirname(__FILE__), '../tagging_overrides')
+require File.join(File.dirname(__FILE__), '../oai_dc_helpers_overrides')
+
+class Topic
+  include TaggingOverrides
+  include OaiDcHelpersOverrides
+end

data/lib/kete_translatable_content/extensions/models/user.rb

@@ -0,0 +1,36 @@
+# extensions to the kete user model
+
+# require the model in Kete before reopening it below
+User
+
+class User
+  def basket_permissions
+    select = "roles.id AS role_id, roles.name AS role_name, baskets.id AS basket_id, baskets.urlified_name AS basket_urlified_name, baskets.name AS basket_name"
+    join = "INNER JOIN baskets on roles.authorizable_id = baskets.id"
+    permissions = roles.find_all_by_authorizable_type('Basket', :select => select, :joins => join)
+
+    # query for matching translations for the baskets in one go
+    basket_ids = permissions.collect { |p| p.basket_id.to_i }
+    translations = Basket::Translation.all(:basket_id => basket_ids, :locale => I18n.locale.to_s)
+
+    logger.debug("what is locale: " + I18n.locale.inspect )
+    logger.debug("what are translations: " + translations.inspect )
+
+    permissions_hash = Hash.new
+    permissions.each do |permission|
+      p = permission.attributes
+
+      # grab the appropriate name for the basket based on locale
+      translation = translations.select { |t| t.basket_id == p['basket_id'].to_i }.first
+      p['basket_name'] = translation ? translation.name : p['basket_name']
+
+      permissions_hash[p['basket_urlified_name'].to_sym] = {
+        :id => p['basket_id'].to_i,
+        :role_id => p['role_id'].to_i,
+        :role_name => p['role_name'],
+        :basket_name => p['basket_name']
+      }
+    end
+    permissions_hash
+  end
+end

data/lib/kete_translatable_content/extensions/models/video.rb

@@ -0,0 +1,12 @@
+# extensions to the kete video model
+
+# require the model in Kete before reopening it below
+Video
+
+require File.join(File.dirname(__FILE__), '../tagging_overrides')
+require File.join(File.dirname(__FILE__), '../oai_dc_helpers_overrides')
+
+class Video
+  include TaggingOverrides
+  include OaiDcHelpersOverrides
+end

data/lib/kete_translatable_content/extensions/models/web_link.rb

@@ -0,0 +1,12 @@
+# extensions to the kete web link model
+
+# require the model in Kete before reopening it below
+WebLink
+
+require File.join(File.dirname(__FILE__), '../tagging_overrides')
+require File.join(File.dirname(__FILE__), '../oai_dc_helpers_overrides')
+
+class WebLink
+  include TaggingOverrides
+  include OaiDcHelpersOverrides
+end

data/lib/kete_translatable_content/extensions/oai_dc_helpers_overrides.rb

@@ -0,0 +1,99 @@
+# redefine helpers to include translated versions
+module OaiDcHelpersOverrides
+  unless included_modules.include? OaiDcHelpersOverrides
+    def self.included(klass)
+      klass.class_eval do
+
+        if self.new.respond_to?(:oai_dc_xml_dc_title)
+          alias_method(:oai_dc_xml_dc_title_orig, :oai_dc_xml_dc_title) unless self.new.respond_to?(:oai_dc_xml_dc_title_orig)
+
+          def oai_dc_xml_dc_title(xml, options = {})
+            is_translatable = Kete.translatables.keys.include?(self.class.name.tableize.singularize)
+
+            # handle original title
+            options = options.merge({ "xml:lang" => locale }) if is_translatable
+            oai_dc_xml_dc_title_orig(xml, options)
+
+            original_title = title
+
+            return unless is_translatable
+
+            @translations_for_this_version ||= self.class::Translation.all(self.class.as_foreign_key_sym => id,
+                                                                           :version => version.to_s)
+            @translations_for_this_version.each do |t|
+              if t.title.present?
+                self.title = t.title
+                options = options.merge({ "xml:lang" => t.locale })
+                oai_dc_xml_dc_title_orig(xml, options)
+              end
+            end
+            self.title = original_title
+          end
+        end
+
+        if self.new.respond_to?(:oai_dc_xml_dc_description)
+          alias_method(:oai_dc_xml_dc_description_orig, :oai_dc_xml_dc_description) unless self.new.respond_to?(:oai_dc_xml_dc_description_orig)
+
+          def oai_dc_xml_dc_description(xml, passed_description = nil, options = {})
+            unless passed_description.blank?
+              oai_dc_xml_dc_description_orig(xml, passed_description, options)
+            else
+              class_name = self.class.name
+              is_translatable = Kete.translatables.keys.include?(class_name.tableize.singularize)
+              has_short_summary = [Topic, Document].include?(self.class)
+
+              options = options.merge({ "xml:lang" => locale }) if is_translatable
+
+              # topic/document specific
+              # order is important, first description will be used as blurb
+              # in result list
+              if has_short_summary && short_summary.present?
+                oai_dc_xml_dc_description(xml, short_summary, options)
+              end
+
+              oai_dc_xml_dc_description(xml, description, options) if description.present?
+
+              return unless is_translatable
+
+              @translations_for_this_version ||= self.class::Translation.all(self.class.as_foreign_key_sym => id,
+                                                                           :version => version.to_s)
+              @translations_for_this_version.each do |t|
+                options = options.merge({ "xml:lang" => t.locale })
+
+                if has_short_summary && t.short_summary.present?
+                  oai_dc_xml_dc_description(xml, t.short_summary, options)
+                end
+
+                if t.description.present?
+                  options = options.merge({ "xml:lang" => t.locale })
+                  oai_dc_xml_dc_description(xml, t.description, options)
+                end
+              end
+            end
+          end
+        end
+
+        if self.new.respond_to?(:oai_dc_xml_tags_to_dc_subjects)
+          alias_method(:oai_dc_xml_tags_to_dc_subjects_orig, :oai_dc_xml_tags_to_dc_subjects) unless self.new.respond_to?(:oai_dc_xml_tags_to_dc_subjects_orig)
+
+          def oai_dc_xml_tags_to_dc_subjects(xml)
+            tags.each do |tag|
+              # handle original
+              xml.send("dc:subject", "xml:lang" => tag.original_locale) {
+                xml.cdata tag.name
+              }
+
+              # do each translation of tag
+              tag.translations.each do |t|
+                xml.send("dc:subject", "xml:lang" => t.locale) {
+                  xml.cdata t.name
+                }
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/kete_translatable_content/extensions/tagging_controller_overrides.rb

@@ -0,0 +1,21 @@
+# for ITEM_CLASSES
+# when new version is created to just add tags
+# we want to update the version attribute of translations
+# that matched previous version
+# to new version number
+module TaggingControllerOverrides
+  unless included_modules.include? TaggingControllerOverrides
+    # method that add-ons can define to do something after tags added
+    def after_tags_added(options)
+      logger.debug("what are after_tags added options: " + options.inspect)
+      # get translations matching starting version
+      translations = @item.class::Translation.all(@item.class.as_foreign_key_sym => @item.id,
+                                                  :version => options[:starting_version].to_s)
+
+      translations.each do |t|
+        t.version = options[:ending_version].to_s
+        t.save!
+      end
+    end
+  end
+end