afalkear_translation_center 0.0.0

data/app/models/translation_center/activity_query.rb

@@ -0,0 +1,46 @@
+module TranslationCenter
+  class ActivityQuery
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    attr_accessor :translation_key_name, :translator_identifier, :lang, :created_at_gteq, :created_at_lteq
+    
+    def persisted?
+      false
+    end
+    
+    def initialize args={}
+      args ||= {}
+      args.each do |k,v|
+        instance_variable_set("@#{k}", v) unless v.blank?
+      end
+    end
+
+    # retuns and ActiveRecord Relation of Audit(s) that matches this search criteria
+    def activities
+      query = Audited::Adapters::ActiveRecord::Audit.where(auditable_id: translation_ids).scoped
+      query = query.where("DATE(created_at) <= DATE(?)", created_at_lteq) unless created_at_lteq.blank?
+      query = query.where("DATE(created_at) >= DATE(?)", created_at_gteq) unless created_at_gteq.blank?
+      query.order('created_at DESC')
+    end
+
+    protected
+
+    # return translation ids that matches this search criteria
+    def translation_ids
+      query = Translation.scoped
+      query = query.where(lang: lang) unless lang.blank?
+      query = query.joins(:translation_key).where("translation_center_translation_keys.name LIKE ?", "%#{translation_key_name}%") unless translation_key_name.blank?
+
+      if translator_identifier
+        translator_class = TranslationCenter::CONFIG['translator_type'].camelize.constantize
+        translators_ids = translator_class.where("#{TranslationCenter::CONFIG['identifier_type']} LIKE ? ", "%#{translator_identifier}%").map(&:id)
+
+        query = query.where(translator_id: translators_ids)
+      end
+
+      query.map(&:id)
+    end
+
+  end
+end

data/app/models/translation_center/category.rb

@@ -0,0 +1,46 @@
+module TranslationCenter
+  class Category < ActiveRecord::Base
+    has_many :translation_keys, dependent: :destroy
+
+    alias_method :keys, :translation_keys
+
+    # validations
+    validates :name, presence: true, uniqueness: true
+
+    # gets how much complete translation of category is in a certain language
+    def complete_percentage_in(lang)
+      if self.keys.empty?
+        100
+      else
+        accepted_keys = accepted_keys(lang)
+        100 * accepted_keys.count / self.keys.count
+      end
+    end
+
+    # gets the keys accepted in a certain language that belong to a category
+    def accepted_keys(lang)
+      self.keys.translated(lang)
+    end
+    alias_method :translated_keys, :accepted_keys
+
+    # gets the keys that have no translations in the language
+    def untranslated_keys(lang)
+      self.keys.untranslated(lang)
+    end
+
+    # gets the keys that have no translations in the language
+    def pending_keys(lang)
+      self.keys.pending(lang)
+    end
+
+    def all_keys(lang)
+      self.keys
+    end
+
+    # returns a name that is better for presentation
+    def view_name
+      self.name.titleize
+    end
+
+  end
+end

data/app/models/translation_center/translation.rb

@@ -0,0 +1,94 @@
+module TranslationCenter
+  class Translation < ActiveRecord::Base
+
+    # attr_accessible :value, :lang, :translation_key_id, :user_id, :status
+    # serialize as we could store arrays
+    serialize :value
+
+    CHANGES_PER_PAGE = 5
+    NUMBER_PER_PAGE = 15
+
+    belongs_to :translation_key
+    belongs_to :translator, polymorphic: true
+
+    alias_method :key, :translation_key
+    acts_as_votable
+    audited
+
+    # validations
+    validates :translation_key_id, :lang, :status, :value, presence: true
+    validate :one_translation_per_lang_per_key, on: :create
+
+    # returns accepted transations
+    #scope :accepted, where(status: 'accepted')
+
+    # returns translations in a certain language
+    scope :in, lambda { |lang| where(lang: lang.to_s.strip) }
+
+    # sorts translations by number of votes
+    # scope :sorted_by_votes, where('votable_type IS NULL OR votable_type = ?', 'TranslationCenter::Translation').select('translation_center_translations.*, count(votes.id) as votes_count').joins('LEFT OUTER JOIN votes on votes.votable_id = translation_center_translations.id').group('translation_center_translations.id').order('votes_count desc')
+
+    after_save :update_key_status
+    after_destroy :notify_key
+
+    def self.accepted(translation_key_id)
+      where(status: 'accepted', translation_key_id: translation_key_id)
+    end
+
+    # called after save to update the key status
+    def update_key_status
+      self.key.update_status self.lang
+    end
+
+    # called before destory to update the key status
+    def notify_key
+      self.key.update_status self.lang
+      self.audits.destroy_all
+    end
+
+    # returns true if the status of the translation is accepted
+    def accepted?
+      self.status == 'accepted'
+    end
+
+    # returns true if the status of the translation is pending
+    def pending?
+      self.status == 'pending'
+    end
+
+    # accept translation by changing its status and if there is an accepting translation
+    # make it pending
+    def accept
+      # if translation is accepted do nothing
+      unless self.accepted?
+        self.translation_key.accepted_translation_in(self.lang).try(:update_attribute, :status, 'pending')
+        # reload the translation key as it has changed
+        self.translation_key.reload
+        self.update_attribute(:status, 'accepted')
+      end
+      
+    end
+
+    # unaccept a translation
+    def unaccept
+      self.update_attribute(:status, 'pending')
+    end
+
+    # gets recent changes on translations
+    # TODO: remove this method as it is not being used elsewhere
+    def self.recent_changes
+      Audited::Adapters::ActiveRecord::Audit.where('auditable_type = ?', 'TranslationCenter::Translation').search(params).relation.reorder('created_at DESC')
+    end
+
+    # make sure user has one translation per key per lang
+    def one_translation_per_lang_per_key
+      if Translation.where(lang: self.lang, translator_id: self.translator.id, translator_type: self.translator.class.name, translation_key_id: self.key.id).empty?
+        true
+      else
+        false
+        self.errors.add(:lang, I18n.t('.one_translation_per_lang_per_key'))
+      end
+    end
+
+  end
+end

data/app/models/translation_center/translation_key.rb

@@ -0,0 +1,188 @@
+module TranslationCenter
+
+  class TranslationKey < ActiveRecord::Base
+    # attr_accessible :name, :last_accessed, :category_id
+    belongs_to :category
+    has_many :translations, dependent: :destroy
+
+    # validations
+    validates :name, uniqueness: true
+    validates :name, presence: true
+
+    # called after key is created or updated
+    before_save :add_category
+
+    PER_PAGE = 7
+
+    scope :translated, lambda { |lang| where("#{lang.to_s}_status" => 'translated') }
+    scope :pending, lambda { |lang| where("#{lang.to_s}_status" => 'pending') }
+    scope :untranslated, lambda { |lang| where("#{lang.to_s}_status" => 'untranslated') }
+
+
+    # add a category of this translation key
+    def add_category
+      category_name = self.name.to_s.split('.').first
+      # if one word then add to general category
+      category_name = self.name.to_s.split('.').size == 1 ? 'general' : self.name.to_s.split('.').first
+      self.category = TranslationCenter::Category.find_or_create_by(name: category_name)
+      self.last_accessed = Time.now
+    end
+
+    # updates the status of the translation key depending on the translations
+    def update_status(lang)
+      if self.translations.in(lang).blank?
+        self.update_attribute("#{lang}_status", 'untranslated')
+      elsif !self.translations.in(lang).accepted(self.id).blank?
+        self.update_attribute("#{lang}_status", 'translated')
+      else
+        self.update_attribute("#{lang}_status", 'pending')
+      end
+    end
+
+    # returns true if the key is translated (has accepted translation) in this lang
+    def accepted_in?(lang)
+      self.send("#{lang}_status") == 'translated'
+    end
+    alias_method :translated_in?, :accepted_in?
+
+    # returns the accepted translation in certain language
+    def accepted_translation_in(lang)
+      self.translations.accepted(self.id).in(lang).first
+    end
+
+    # returns true if the translation key is untranslated (has no translations) in the language
+    def no_translations_in?(lang)
+      self.send("#{lang}_status") == 'untranslated'
+    end
+    alias_method :untranslated_in?, :no_translations_in?
+
+    # returns true if the key has translations in the language
+    def has_translations_in?(lang)
+      !no_translations_in?(lang)
+    end
+
+    # returns true if the key is pending (has translations but none is accepted)
+    def pending_in?(lang)
+      self.send("#{lang}_status") == 'pending'
+    end
+
+    # returns the status of the key in a language
+    def status(lang)
+      if accepted_in?(lang)
+        'translated'
+      elsif pending_in?(lang)
+        'pending'
+      else
+        'untranslated'
+      end
+    end
+
+    # create default translation
+    def create_default_translation
+      translation = self.translations.build(value: self.name.to_s.split('.').last.titleize,
+                                            lang: :en, status: 'accepted')
+      translation.translator = TranslationCenter.prepare_translator
+
+      translation.save
+    end
+
+    def self.keys_count
+      TranslationKey.all.count
+    end
+
+    # returns the count of translated keys in lang
+    def self.translated_count(lang)
+      TranslationKey.translated(lang).count
+    end
+
+    # returns the count of pending keys in lang
+    def self.pending_count(lang)
+      TranslationKey.pending(lang).count
+    end
+
+    # returns the count of untranslated keys in lang
+    def self.untranslated_count(lang)
+      TranslationKey.untranslated(lang).count
+    end
+
+    # returns the percentage of translated keys in lang
+    def self.translated_percentage(lang)
+      (100.0 * TranslationKey.translated(lang).count / keys_count).round(2)
+    end
+
+    # returns the percentage of pending keys in lang
+    def self.pending_percentage(lang)
+      (100.0 * TranslationKey.pending(lang).count / keys_count).round(2)
+    end
+
+    # returns the percentage of untranslated keys in lang
+    def self.untranslated_percentage(lang)
+      (100.0 * TranslationKey.untranslated(lang).count / keys_count).round(2)
+    end
+
+    # builds hash of stats about the langs supported by translation center
+    def self.langs_stats
+      stats = {}
+      all_count = keys_count
+      I18n.available_locales.each do |locale|
+        stats[locale] = {}
+        stats[locale]['name'] = TranslationCenter::CONFIG['lang'][locale.to_s]['name']
+
+        translated = translated_count(locale)
+        pending = pending_count(locale)
+        untranslated = untranslated_count(locale)
+
+        stats[locale]['translated_percentage'] = (100.0 * translated / all_count).round(2)
+        stats[locale]['pending_percentage'] = (100.0 * pending / all_count).round(2)
+        stats[locale]['untranslated_percentage'] = (100.0 * untranslated / all_count).round(2)
+
+        stats[locale]['translated_count'] = translated
+        stats[locale]['pending_count'] = pending
+        stats[locale]['untranslated_count'] = untranslated
+      end
+      stats
+    end
+
+    def children_translations(locale)
+      TranslationKey.where('name LIKE ?', "#{self.name}.%").inject({}) do |translations, child|
+        translations[child.name.split('.').last.to_sym] = child.accepted_translation_in(locale).try(:value)
+        translations
+      end
+    end
+
+    def has_children?
+      TranslationKey.where('name LIKE ?', "#{self.name}.%").count >= 1
+    end
+
+    # adds a translation key with its translation to a translation yaml hash
+    # send the hash and the language as parameters
+    def add_to_hash(all_translations, lang)
+      levels = self.name.split('.')
+      add_to_hash_rec(all_translations, levels, lang.to_s)
+    end
+
+    private
+      def add_to_hash_rec(all_translations, levels, lang)
+        current_level = levels.first
+        # if we are at the bottom level just return the translation
+        if(levels.count == 1)
+          translation = self.accepted_translation_in(lang)
+          formatted = translation.value
+          # in case of arrays remove the unneeded header
+          formatted.to_yaml.gsub!("---\n" , '') if formatted.is_a?(Array)
+          {current_level => formatted}
+        else
+          levels.shift
+          # if the translation key doesn't exist at current level then create it
+          unless(all_translations.has_key?(current_level))
+            all_translations[current_level] = {}
+          end
+          # merge the current level with the rest of the translation key
+          all_translations[current_level].merge!( add_to_hash_rec(all_translations[current_level],levels, lang) )
+          all_translations
+        end
+      end
+
+  end
+
+end

data/app/views/layouts/translation_center/application.html.haml

@@ -0,0 +1,82 @@
+!!!
+%html
+  %head
+    %title TranslationCenter
+
+    = stylesheet_link_tag    "translation_center/application", :media => "all"
+    = javascript_include_tag "translation_center/application"
+    = csrf_meta_tags
+  %body
+
+
+    .navbar.navbar-fixed-top
+      .navbar-inner
+        .container
+          %a.btn.btn-navbar{"data-target" => ".navbar-responsive-collapse", "data-toggle" => "collapse"}
+            %span.icon-bar
+            %span.icon-bar
+            %span.icon-bar
+          %a.brand{:href => root_url}
+            = favicon_link_tag
+            = Rails.application.class.parent_name
+            %em.center_title
+              = t('translation_center.translation_center')
+          .nav-collapse.collapse.navbar-responsive-collapse
+            %ul.nav
+              %li.divider-vertical
+              / .pull-left.nav_text
+              /   = t('.from')
+              / %li.dropdown.pull-left
+                
+              /   %a.dropdown-toggle{"data-toggle" => "dropdown", href: '#'}
+              /     = language_name(from_lang)
+              /     %b.caret
+              /   %ul.dropdown-menu
+              /     - I18n.available_locales.each do |locale|
+              /       %li
+              /         %a.language_from{ href: '#', lang_sym: locale}
+              /           = language_name(locale)
+              
+              .pull-left.nav_text
+                %span
+                  = t('translation_center.translate_to')
+              %li.dropdown.pull-left
+                %a.dropdown-toggle{"data-toggle" => "dropdown", href: '#'}
+                  = language_name(to_lang)
+                  %b.caret
+                %ul.dropdown-menu
+                  - I18n.available_locales.each do |locale|
+                    %li
+                      %a.language_to{ href: change_locale_url(locale), lang_sym: locale}
+                        = language_name(locale)
+              - if translation_admin?
+                .pull-left.nav_text
+                  %span
+                    = link_to t('translation_center.dashboard'), dashboard_path
+              %li.divider-vertical
+              %form.navbar-search
+                %input#search_keys.search-query{placeholder: t('translation_center.search_keys'), type: "text", autocomplete: :off}
+              %form.navbar-search{action: search_translations_path}
+                %input#translations.search-query{placeholder: t('translation_center.search_translations'), type: "text", autocomplete: :off, name: :translation_value, value: params[:translation_value]}
+            
+            %ul.nav.pull-right
+              %li
+                = link_to t('translation_center.back_to_app'), main_app.root_path, target: Rails.application.class.parent_name
+    - if flash[:alert] 
+      .alert.alert-error
+        %button{ type: 'button', class: 'close', 'data-dismiss' => 'alert' }
+          ×
+        = flash[:alert]
+
+    - if flash[:notice]
+      .alert.alert-success
+        %button{ type: 'button', class: 'close', 'data-dismiss' => 'alert' }
+          ×
+        = flash[:notice]
+        
+    .container
+      .row
+        .span12
+          %input#tc_no_inspector{ value: 'true' ,type: :hidden }
+          = yield
+        

data/app/views/translation_center/categories/_category.html.haml

@@ -0,0 +1,11 @@
+%a.category{ href: category_path(category) }
+  .category_name
+    = category.view_name
+  %div
+    %span.label.label-info
+      = category.translation_keys.count
+      = t('.keys')
+    - completion = category.complete_percentage_in(to_lang)
+    %span{ class: completion == 100 ? 'label label-success' : 'label label-important'}
+      = "#{completion} %"
+      = t('.complete')

data/app/views/translation_center/categories/index.html.haml

@@ -0,0 +1,7 @@
+%h1
+  = t('.categories')
+
+- @categories.each do |category|
+  = render 'category', category: category
+
+%br/

data/app/views/translation_center/categories/keys.js.haml

@@ -0,0 +1,10 @@
+- @keys.each_with_index do |key, index|
+  $('.translation_keys_listing').append("#{escape_javascript(render 'translation_center/translation_keys/show_keys', translation_key: key, index: -1)}")  
+
+
+- @keys.each_with_index do |key, index|
+  $('.translations_listing').append("#{escape_javascript(render 'translation_center/translation_keys/show', translation_key: key, index: -1)}")  
+
+editableTranslations();
+editableKeyTranslations();
+

data/app/views/translation_center/categories/show.html.haml

@@ -0,0 +1,32 @@
+%input#category_key{ type: 'hidden', value: @category.id }
+%input#current_filter{ type: 'hidden', value: current_filter }
+%h1
+  = @category.name.camelize
+%ul.nav.nav-pills
+  
+  %li{class: "#{current_filter_is?('untranslated') ? 'active' : ''}"}
+    %a#untranslated.keys_filter{:href => "#"}
+      = t('.untranslated')
+      %span#untranslated_keys_count
+        = "(#{@untranslated_keys_count})"
+  %li{class: "#{current_filter_is?('pending') ? 'active' : ''}"}
+    %a#pending.keys_filter{:href => "#"}
+      = t('.pending')
+      %span#pending_keys_count
+        = "(#{@pending_keys_count})"
+  %li{class: "#{current_filter_is?('translated') ? 'active' : ''}"}
+    %a#translated.keys_filter{:href => "#"}
+      = t('.translated')
+      %span#translated_keys_count
+        = "(#{@translated_keys_count})"
+  %li{class: "#{current_filter_is?('all') ? 'active' : ''}"}
+    %a#all.keys_filter{:href => "#"}
+      = t('.all')
+      %span#all_keys_count
+        = "(#{@all_keys_count})"
+  %li
+    #loading
+      = image_tag 'translation_center/loading.gif'
+.span9#category
+  = render 'translation_center/translation_keys/translation_keys', translation_keys: @keys, category: @category
+

data/app/views/translation_center/categories/show.js.haml

@@ -0,0 +1,7 @@
+$('#category').html("#{escape_javascript(render 'translation_center/translation_keys/translation_keys', translation_keys: @keys, category: @category)}")
+$('#translated_keys_count').text("(#{@translated_keys_count})");
+$('#pending_keys_count').text("(#{@pending_keys_count})");
+$('#untranslated_keys_count').text("(#{@untranslated_keys_count})");
+current_page = 1;
+editableTranslations();
+editableKeyTranslations();

data/app/views/translation_center/center/_activity.html.haml

@@ -0,0 +1,49 @@
+- if translations_changes.empty?
+  .alert.alert-info
+    = t('.no_matches')
+- else
+  %table.table.table-striped.table-bordered
+    %thead
+      %tr
+        %th
+          = t('.key')
+        %th
+          = t('.locale')
+        %th
+          = t('.user')
+        %th
+          = t('.changes')
+        %th
+          = t('.time')
+
+    %tbody
+      - translations_changes.each do |change|
+        %tr
+          %td
+            = link_to change.auditable.key.name, change.auditable.key, target: '_blank'
+          %td
+            = change.auditable.lang
+          %td
+            = change.auditable.translator.try TranslationCenter::CONFIG['identifier_type']
+          %td
+            %ul
+              - change.audited_changes.each do |change, value|
+                %li
+                  = format_change(change, value)
+          %td
+            = distance_of_time_in_words_to_now change.created_at
+            = t('.ago')
+  .pagination
+    - query_without_page_param = request.query_string.gsub(/&?page=\d*/, '')
+    = link_to t('pagination.first'), "#{request.protocol}#{request.host_with_port}#{request.path}?#{query_without_page_param}&page=1"
+    - if @page != 1
+      |
+      = link_to t('pagination.prev'), "#{request.protocol}#{request.host_with_port}#{request.path}?#{query_without_page_param}&page=#{@page - 1}"
+    |
+    = link_to t('pagination.next'), "#{request.protocol}#{request.host_with_port}#{request.path}?#{query_without_page_param}&page=#{@page + 1}"
+    - if @page != @total_pages
+      |
+      = link_to t('pagination.last'), "#{request.protocol}#{request.host_with_port}#{request.path}?#{query_without_page_param}&page=#{@total_pages}"
+    = @page
+    = t('.of')
+    = @total_pages

data/app/views/translation_center/center/dashboard.html.haml

@@ -0,0 +1,102 @@
+%h1
+  = t('.controls')
+
+.well
+  .alert#operation_progress
+    %button.close{"data-dismiss" => "alert", :type => "button"} ×
+    %strong
+      = t('.these_actions_will_affect_existing_data')
+  = form_tag manage_translations_path, remote: true, id: 'manage_form', class: 'form-search' do
+    = select_tag 'locale', options_for_select(I18n.available_locales.collect{ |locale| [language_name(locale), locale.to_s] }.insert(0, [t('.all'), 'all'])), {:prompt => t('.select_locale')}
+    = hidden_field_tag :manage_action
+    = link_to 'yaml2db', '#', class: 'manage-button btn btn-primary', 'data-action' => 'yaml2db'
+    = link_to 'db2yaml', '#', class: 'manage-button btn btn-primary', 'data-action' => 'db2yaml'
+    #spinner
+
+%h1
+  = t('.dashboard')
+
+.span12
+  %table.table.table-striped.table-bordered
+    %thead
+      %tr
+        %th
+          = t('.language')
+        %th
+          = t('.progress')
+        %th
+          = t('.translated')
+        %th
+          = t('.pending')
+        %th
+          = t('.untranslated')
+
+
+    %tbody
+      - @langs.each do |lang|
+        %tr
+          %td
+            = link_to @stats[lang]['name'], set_lang_to_path(lang: lang.to_s)
+          %td
+            .progress
+              .bar.bar-success{ style: "width: #{@stats[lang]['translated_percentage']}%;" }
+              .bar.bar-warning{ style: "width: #{@stats[lang]['pending_percentage']}%;" }
+              .bar.bar-danger{ style: "width: #{@stats[lang]['untranslated_percentage']}%;" }
+          %td
+            = "#{@stats[lang]['translated_count']}(#{@stats[lang]['translated_percentage']}%)"
+          %td
+            = "#{@stats[lang]['pending_count']}(#{@stats[lang]['pending_percentage']}%)"
+          %td
+            = "#{@stats[lang]['untranslated_count']}(#{@stats[lang]['untranslated_percentage']}%)"
+%h1
+  = t('.activity')
+.span12
+
+  = form_for @activity_query, url: :search_activity, html: { method: :get, id: :search_form, class: 'pull-left form-search' } do |f|
+    = f.text_field :translation_key_name, class: 'search_field input-medium',  placeholder: 'KEY'
+
+    = f.select :lang, I18n.available_locales.collect { |locale| [locale.to_s, locale.to_s] }, {:include_blank => t('.select_locale')}, class: 'search_field'
+
+    = f.text_field :translator_identifier, class: 'search_field input-medium',  placeholder: translator_identifier_placeholder
+
+    = f.text_field :created_at_gteq, class: 'search_field datepicker input-medium',  placeholder: 'FROM DATE'
+
+    = f.text_field :created_at_lteq, class: 'search_field datepicker input-medium', placeholder: 'TO DATE'
+
+    %button.btn#search_activity{ type: :button }
+      = t('.search')
+    %button.btn#search_reset{ type: :button }
+      = t('.reset')
+    
+  #activity
+    = render 'activity', translations_changes: @translations_changes
+
+
+:javascript
+  $('.manage-button').click(function(){
+    if(confirm('Are you sure you want to perform this operation ?'))
+    {
+      $('#spinner').show();
+      var target = document.getElementById('spinner');
+      var spinner = new Spinner(spinner_params).spin(target);
+      $('#manage_action').val($(this).data('action'))
+      $('#operation_progress').removeClass('alert-success')
+      var msg = $(this).data('action') == 'yaml2db' ? 'Transfering yaml translations to db' : 'Transfering db translations to yaml files'
+      $('#operation_progress strong').text(msg)
+      $('#manage_form').submit()
+    }
+    return false;
+  })
+
+  // hit search directly when pressing enter
+  $(".search_field").keyup(function(event){
+    if(event.keyCode == 13){
+        $('#search_activity').click();
+    }
+  });
+
+      
+
+
+  
+