lesli_babel 0.1.0

data/app/services/lesli_babel/old/translations_rails_service.rb

@@ -0,0 +1,119 @@
+module LesliBabel
+    class TranslationsRailsService
+
+        def self.build
+
+            engines_installed = Rails.application.config.lesli_settings["engines"].map do |engine|
+                engine[:name]
+            end
+
+            # get all rails engines to buil
+            engines = Module
+                .where("platform in ('rails_core', 'rails_builder', 'rails_engine', 'standard')")
+                .where("name in (?)", engines_installed.push("Core","LesliMails"))
+                .map do |engine|
+                engine[:id]
+            end
+
+            # get strings filtered by module (only rails translations)
+            strings = TranslationsService.strings(engines)
+
+            strings = strings.select(
+                :id,
+                :label,
+                :status,
+                :context,
+                :priority,
+                :need_help,
+                :need_translation,
+                Rails.application.config.lesli_settings["configuration"]["locales"],
+                "cloud_babel_modules.id as engine_id",
+                "cloud_babel_buckets.id as bucket_id",
+                "cloud_babel_buckets.name as bucket_name",
+                "cloud_babel_modules.name as engine_name",
+                "cloud_babel_modules.platform as platform",
+                "'' as path"
+            )
+
+            translations = {}
+
+            available_locales = Rails.application.config.lesli_settings["configuration"]["locales"]
+
+            # add key for every available language (required by i18n Rails gem)
+            available_locales.each do |lang|
+                translations[lang] = { }
+            end
+
+            strings.each do |string|
+                module_name = string[:engine_name].downcase.sub("cloud", "")
+                engine_code = string[:engine_name].underscore
+                engine_name = string[:engine_name]
+                bucket_name = string[:bucket_name]
+                platform = string[:platform]
+
+                available_locales.each do |lang|
+
+                    # translations path for lesli core
+                    file_path = Rails.root.join("config", "locales", bucket_name, "#{ bucket_name.gsub("/","_") }.#{ lang }.yml")
+
+                    # translations path for translations for engines
+                    if platform == "rails_builder" || platform == "rails_engine" || platform == "standard"
+                        file_path = Rails.root.join("engines", engine_name, "config", "locales", bucket_name, "#{ bucket_name }.#{ lang }.yml")
+                        file_path = Rails.root.join("config", "locales", engine_code, bucket_name, "#{ bucket_name.gsub("/","_") }.#{ lang }.yml")
+                    end
+
+                    file_id = file_path.to_s.to_sym
+
+                    unless translations[lang].has_key? file_id
+                        translations[lang][file_id] = { }
+                    end
+
+                    unless translations[lang][file_id].has_key? module_name
+                        translations[lang][file_id][module_name] = { }
+                    end
+
+                    unless translations[lang][file_id][module_name].has_key? bucket_name
+                        translations[lang][file_id][module_name][bucket_name] = { }
+                    end
+
+                    # send debug message for missing translations
+                    string[lang] = ":" + string.path + ":" if string[lang].blank?
+
+                    translations[lang][file_id][module_name][bucket_name][string.label] = string[lang]
+
+                end
+
+            end
+
+            translations.each do |file_by_language|
+
+                lang = file_by_language[0]
+                file_by_controller = file_by_language[1]
+
+                file_by_controller.each do |file|
+
+                    file_path = file[0].to_s
+                    translations = file[1]
+
+                    # creates folder and subfolders
+                    FileUtils.makedirs(File.dirname(file_path))
+
+                    # creates translation file for every available language
+                    translation_file = File.new(file_path, "w+")
+
+                    translation_file.write({ "#{lang}": translations}.to_yaml)
+
+                    translation_file.close
+
+                    p "file added: #{ file_path }"
+
+                end
+
+            end
+
+            LC::Response.service true, translations
+
+        end
+
+    end
+end

data/app/services/lesli_babel/old/translations_service.rb

@@ -0,0 +1,97 @@
+=begin
+
+Lesli
+
+Copyright (c) 2020, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to 
+industrial property, intellectual property, copyright and relative international laws. 
+All intellectual or industrial property rights of the code, texts, trade mark, design, 
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+
+=end
+module LesliBabel
+    class TranslationsService
+
+        def self.restart_server
+            return if Rails.env != "production"
+            system "bundle exec rake i18n:js:export RAILS_ENV=production"
+            FileUtils.touch Rails.root.join("tmp", "restart.txt")
+        end
+
+        def self.clean
+
+            # store full path to translation files for every language
+            files_to_delete = []
+
+            # remove javascript translation cache
+            files_to_delete.push(Rails.root.join("public", "javascripts", "translations.js"))
+
+            # get translation files for engines only
+            Lesli::engines.each do |engine|
+                files_to_delete.push(Rails.root.join("engines", engine["name"], "config", "locales"))
+            end
+
+            # include translation files for lesli core
+            files_to_delete.push(Rails.root.join("config", "locales"))
+
+            # include external app translations
+            files_to_delete.push(Rails.root.join("public", "tmp", "locales"))
+
+            # delete all the translation files found
+            files_to_delete.each do |file|
+                FileUtils.rm_rf(file)
+            end
+
+            LC::Response.service true, files_to_delete
+
+        end
+
+        def self.strings engines_id=nil, buckets_id=nil
+
+            # get strings with bucket and module information
+            strings = String
+            .joins("inner join cloud_babel_buckets on cloud_babel_buckets.id = cloud_babel_strings.cloud_babel_buckets_id and cloud_babel_buckets.deleted_at is NULL")
+            .joins("inner join cloud_babel_modules on cloud_babel_modules.id = cloud_babel_buckets.cloud_babel_modules_id and cloud_babel_modules.deleted_at is NULL")
+            .where("cloud_babel_modules.id in (?)", TranslationsService.installed_engines_id)
+
+            # filter by specific engines
+            if engines_id
+                strings = strings.where("cloud_babel_modules.id in (?)", engines_id)
+            end
+
+            # filter by specific engine buckets 
+            if buckets_id
+                strings = strings.where("cloud_babel_buckets.id in (?)", buckets_id)
+            end
+
+            strings
+
+        end
+
+        def self.strings_for_apps engines_id=nil, buckets_id=nil
+
+            strings = strings(engines_id, buckets_id)
+            strings = strings.select(
+                :id, 
+                :label,
+                "cloud_babel_modules.name as engine_name",
+                "cloud_babel_buckets.name as bucket_name",
+                "cloud_babel_modules.platform",
+                Rails.application.config.lesli_settings["configuration"]["locales"]
+            )
+
+            strings
+
+        end
+
+    end
+end

data/app/services/lesli_babel/old/translations_synchronization_service.rb

@@ -0,0 +1,215 @@
+=begin
+
+Copyright (c) 2020, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to 
+industrial property, intellectual property, copyright and relative international laws. 
+All intellectual or industrial property rights of the code, texts, trade mark, design, 
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+
+=end
+
+module LesliBabel
+    class TranslationsSynchronizationService
+
+        # IMPORTANT: If you modify this file please check the CloneService that contains a modified
+        # copy of this synchronization code
+        def self.remote_sync double_way_sync=false
+
+            host = "http://localhost:8080"
+            host = "https://api.datenbanken.dev/v2"
+            instance_code = LC::System::Info.instance[:code].gsub("_","-")
+
+            # if special namespace is configured in the lesli.yml settings
+            # this is useful when we need install an instance and customize
+            # the translations for a client
+            #instance_code = Rails.application.config.lesli.dig(:configuration, :babel, :namespace)
+
+            api_endpoint = "#{host}/buckets/#{instance_code}-babel/documents"
+
+
+            # get last sync data
+            response = Faraday.get("#{api_endpoint}/last")
+            response = FastJsonparser.parse(response.body)
+            response = response[:documents][0]
+
+            # if first time sync
+            response = FastJsonparser.parse({ modules: [], buckets: [], strings: [] }.to_json) if response.blank?
+
+            # add new modules
+            response[:modules].each do |babel_module|
+                next if babel_module[:name].blank?
+
+                local_module = CloudBabel::Module
+                .create_with({
+                    created_at: babel_module[:created_at],
+                    platform: babel_module[:platform]
+                }).find_or_create_by({ name: babel_module[:name] })
+
+                platform = babel_module[:platform]
+                platform = "rails_engine"   if babel_module[:name].start_with?("Cloud")
+                platform = "rails_core"     if babel_module[:name] == "Core"
+                platform = "rails_builder"  if ["MitwerkenCloud", "DeutscheLeibrenten", "LesliCloud"].include?(babel_module[:name])
+
+                local_module.platform = platform
+                local_module.updated_at = DateTime.now
+                local_module.save
+
+            end
+
+            # working with buckets
+            babel_reference_modules = {}
+
+            response[:buckets].each do |babel_bucket|
+
+                next if babel_bucket[:name].blank?
+
+                # reference to modules that buckets belongs to
+                # this reference as string is necessary because the id of the module can change
+                # between synchronizations, thats why we search for the id of the module every time
+                if babel_reference_modules[babel_bucket[:reference_module]].blank?
+                    babel_reference_modules[babel_bucket[:reference_module]] =
+                    CloudBabel::Module.find_by(name: babel_bucket[:reference_module])
+                end
+
+                # add new bucket
+                CloudBabel::Bucket
+                .create_with({
+                    created_at: babel_bucket[:created_at],
+                    module: babel_reference_modules[babel_bucket[:reference_module]]
+                }).find_or_create_by({
+                    name: babel_bucket[:name],
+                    reference_module: babel_bucket[:reference_module]
+                })
+
+            end
+
+            # · working with strings
+            babel_reference_buckets = {}
+
+            response[:strings].each do |remote_string|
+                # reference to modules that buckets belongs to
+                # this reference as string is necessary because the id of the module or bucket can change
+                # between synchronizations, thats why we search for the id of the module every time
+                if babel_reference_buckets[remote_string[:reference_bucket]].blank?
+                    remote_string[:reference_bucket] ||= remote_string[:reference_module_bucket]
+                    babel_reference_buckets[remote_string[:reference_bucket]] = 
+                    CloudBabel::Bucket.find_by(
+                        name: remote_string[:reference_bucket].split("-")[1],
+                        reference_module: remote_string[:reference_bucket].split("-")[0]
+                    )
+                end
+
+                # Do not sync labes that do not have a valid module and bucket reference
+                next if babel_reference_buckets[remote_string[:reference_bucket]].blank?
+            
+                remote_string_reference = "#{babel_reference_buckets[remote_string[:reference_bucket]].reference_module}-#{babel_reference_buckets[remote_string[:reference_bucket]].name}"
+
+                # add new string if it does not exist
+                local_string = CloudBabel::String.with_deleted.create_with({
+                    bucket: babel_reference_buckets[remote_string[:reference_bucket]]
+                }).find_or_create_by({
+                    label: remote_string[:label],
+                    reference_module_bucket: remote_string_reference
+                })
+
+                # if status changed
+                if remote_string[:status] != local_string["status"]
+
+                    remote_string[:last_update_status] = Time.now if remote_string[:last_update_status].blank?
+                    local_string["last_update_status"] = Time.now if local_string["last_update_status"].blank?
+
+                    # check if remote is newer than local
+                    if (remote_string[:last_update_status] > local_string["last_update_status"])
+
+                        # if so, update local translation with the incoming
+                        local_string["status"] = remote_string[:status]
+                        local_string["last_update_status"] = remote_string[:last_update_status]
+
+                    end
+
+                end
+
+                # if context changed
+                if remote_string[:context] != local_string["context"]
+
+                    remote_string[:last_update_context] = Time.now if remote_string[:last_update_context].blank?
+                    local_string["last_update_context"] = Time.now if local_string["last_update_context"].blank?
+
+                    # check if remote is newer than local
+                    if (remote_string[:last_update_context] > local_string["last_update_context"])
+
+                        # if so, update local translation with the incoming
+                        local_string["context"] = remote_string[:context]
+                        local_string["last_update_context"] = remote_string[:last_update_context]
+
+                    end
+
+                end
+
+                # check if necessary to update any translation
+                # due babel can work as client and server at the same time, we have to synchronize labels for all supported languages
+                I18n.available_locales.each do |locale|
+
+                    # parse the remote time for comparison, if no time use the current time
+                    remote_time = Time.parse remote_string[:"last_update_#{locale}"] rescue Time.now.getutc
+
+                    # parse the remote time for comparison, if no time use old time so we can update the string
+                    local_time = Time.parse local_string["last_update_#{locale}"] rescue Time.parse("Jan 1900")
+
+                    # if translation changed
+                    if local_string[locale] != remote_string[:"#{locale}"]
+            
+                        # check if remote is newer than local
+                        if (remote_time > local_time)
+            
+                            # if so, update local translation with the incoming
+                            local_string[locale] = local_time
+                            local_string["last_update_#{locale}"] = remote_time
+
+                        end
+            
+                    end
+                    
+                end
+
+                local_string.save
+
+            end
+
+            return LC::Response.service(true) if double_way_sync == false
+
+            # · Collect modules, buckets and strings for syncronization
+
+            # get and parse modules
+            modules = CloudBabel::Module.all.map do |babel_module|
+                babel_module.as_json
+            end
+
+            # get and parse buckets
+            buckets = CloudBabel::Bucket.all.map do |babel_bucket|
+                babel_bucket.as_json
+            end
+
+            # get and parse strings including the deleted ones
+            strings = CloudBabel::String.with_deleted.all.map do |babel_string|
+                babel_string.as_json
+            end
+
+            # send latest translation to raven
+            response = Faraday.post(api_endpoint, ({ modules: modules, buckets: buckets, strings: strings }).to_json, "Content-Type" => "application/json")
+
+            LC::Response.service true
+
+        end
+
+    end
+end

data/app/services/lesli_babel/string_service.rb

@@ -0,0 +1,80 @@
+module LesliBabel
+    class StringService < Lesli::ApplicationLesliService
+
+        def list engines_id=nil, buckets_id=nil
+
+            # get strings with bucket and module information
+            strings = String
+            .joins("inner join lesli_babel_buckets on lesli_babel_buckets.id = lesli_babel_strings.bucket_id and lesli_babel_buckets.deleted_at is NULL")
+            .joins("inner join lesli_babel_modules on lesli_babel_modules.id = lesli_babel_buckets.module_id and lesli_babel_modules.deleted_at is NULL")
+            .where("lesli_babel_modules.id in (?)", ModuleService.new(current_user, query).list())
+
+            # filter by specific engines
+            if engines_id
+                strings = strings.where("lesli_babel_modules.id in (?)", engines_id)
+            end
+
+            # filter by specific engine buckets 
+            if buckets_id
+                strings = strings.where("lesli_babel_buckets.id in (?)", buckets_id)
+            end
+
+            strings
+        end
+
+        def index params
+            strings = self.list.select(
+                :id,
+                :label,
+                :status,
+                :context,
+                Lesli.config.locales.keys,
+                "lesli_babel_modules.id as engine_id",
+                "lesli_babel_buckets.id as bucket_id",
+                "lesli_babel_buckets.name as bucket_name",
+                "lesli_babel_modules.name as engine_name",
+                "lesli_babel_modules.platform as platform",
+                "'' as path"
+            )
+
+            strings = strings
+            .page(query[:pagination][:page])
+            .per(query[:pagination][:perPage])
+            .order(:updated_at)
+        end
+
+        def stats
+
+            Rails.cache.fetch("babel/strings/stats", expires_in: 1.hour) do
+
+                # total translations registered in babel
+                total_strings = self.list.count
+                
+                # total translations by language
+                total_strings_translations = []
+
+                #Rails.application.config.lesli.dig(:configuration, :locales_available).each do |locale|
+                Lesli.config.locales.each do |locale|
+                    total_strings_translations.push({
+                        code: locale[0],
+                        name: locale[1],
+                        total: self.list.where("#{locale[0]} is not null").where("#{locale[0]} != ''").count
+                    })
+                end
+
+                # total translations that needs help
+                total_strings_waiting_for_help = self.list.where(:status => 1).count
+
+                # total translations that needs translation
+                total_strings_waiting_for_translation = self.list.where(:status => 2).count
+
+                {
+                    total_strings: total_strings,
+                    total_strings_translations: total_strings_translations,
+                    total_strings_waiting_for_help: total_strings_waiting_for_help,
+                    total_strings_waiting_for_translation: total_strings_waiting_for_translation
+                }
+            end
+        end
+    end
+end

data/app/views/lesli_babel/buckets/_form.html.erb

@@ -0,0 +1,17 @@
+<%= form_with(model: bucket, local: true) do |form| %>
+  <% if bucket.errors.any? %>
+    <div id="error_explanation">
+      <h2><%= pluralize(bucket.errors.count, "error") %> prohibited this bucket from being saved:</h2>
+
+      <ul>
+        <% bucket.errors.full_messages.each do |message| %>
+          <li><%= message %></li>
+        <% end %>
+      </ul>
+    </div>
+  <% end %>
+
+  <div class="actions">
+    <%= form.submit %>
+  </div>
+<% end %>

data/app/views/lesli_babel/buckets/edit.html.erb

@@ -0,0 +1,6 @@
+<h1>Editing Bucket</h1>
+
+<%= render 'form', bucket: @bucket %>
+
+<%= link_to 'Show', @bucket %> |
+<%= link_to 'Back', buckets_path %>

data/app/views/lesli_babel/buckets/index.html.erb

@@ -0,0 +1,25 @@
+<p id="notice"><%= notice %></p>
+
+<h1>Buckets</h1>
+
+<table>
+  <thead>
+    <tr>
+      <th colspan="3"></th>
+    </tr>
+  </thead>
+
+  <tbody>
+    <% @buckets.each do |bucket| %>
+      <tr>
+        <td><%= link_to 'Show', bucket %></td>
+        <td><%= link_to 'Edit', edit_bucket_path(bucket) %></td>
+        <td><%= link_to 'Destroy', bucket, method: :delete, data: { confirm: 'Are you sure?' } %></td>
+      </tr>
+    <% end %>
+  </tbody>
+</table>
+
+<br>
+
+<%= link_to 'New Bucket', new_bucket_path %>

data/app/views/lesli_babel/buckets/new.html.erb

@@ -0,0 +1,5 @@
+<h1>New Bucket</h1>
+
+<%= render 'form', bucket: @bucket %>
+
+<%= link_to 'Back', buckets_path %>

data/app/views/lesli_babel/buckets/show.html.erb

@@ -0,0 +1,4 @@
+<p id="notice"><%= notice %></p>
+
+<%= link_to 'Edit', edit_bucket_path(@bucket) %> |
+<%= link_to 'Back', buckets_path %>

data/app/views/lesli_babel/clones/_form.html.erb

@@ -0,0 +1,19 @@
+<%
+=begin
+Copyright (c) 2021, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to 
+industrial property, intellectual property, copyright and relative international laws. 
+All intellectual or industrial property rights of the code, texts, trade mark, design, 
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+
+=end
+%>

data/app/views/lesli_babel/clones/edit.html.erb

@@ -0,0 +1,20 @@
+<%
+=begin
+Copyright (c) 2021, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to 
+industrial property, intellectual property, copyright and relative international laws. 
+All intellectual or industrial property rights of the code, texts, trade mark, design, 
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+
+=end
+%>
+<router-view></router-view>

data/app/views/lesli_babel/clones/index.html.erb

@@ -0,0 +1,20 @@
+<%
+=begin
+Copyright (c) 2021, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to 
+industrial property, intellectual property, copyright and relative international laws. 
+All intellectual or industrial property rights of the code, texts, trade mark, design, 
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+
+=end
+%>
+<router-view></router-view>

data/app/views/lesli_babel/clones/new.html.erb

@@ -0,0 +1,20 @@
+<%
+=begin
+Copyright (c) 2021, all rights reserved.
+
+All the information provided by this platform is protected by international laws related  to 
+industrial property, intellectual property, copyright and relative international laws. 
+All intellectual or industrial property rights of the code, texts, trade mark, design, 
+pictures and any other information belongs to the owner of this platform.
+
+Without the written permission of the owner, any replication, modification,
+transmission, publication is strictly forbidden.
+
+For more information read the license file including with this software.
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+
+=end
+%>
+<router-view></router-view>