lesli_babel 0.4.0 → 0.6.0

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

@@ -1,77 +0,0 @@
-module LesliBabel
-    class TranslationsMiddlemanService
-
-        def self.build(engine_id)
-
-            # get all rails engines
-            engines = Module.where(:id => engine_id).map(&:id)
-            
-            # get strings filtered by module (only rails translations)
-            strings = TranslationsService.strings_for_apps(engines)
-
-            indexes = {}
-            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] = { :path => '', :labels => {} }
-            end
-
-            strings.each do |string|
-
-                module_name = string[:engine_name].downcase.sub("cloud", "")
-                engine_name = string[:engine_name]
-                bucket_name = string[:bucket_name]
-                module_type = string[:platform]
-                
-                bucket_name_clean = bucket_name.gsub("/","_")
-
-                available_locales.each do |lang|
-
-                    file_path = Rails.root.join(
-                        "public", "tmp", "babel", "middleman","locales", "#{lang}.yml"
-                    )
-
-                    translations[lang][:file] = file_path.to_s
-
-                    unless translations[lang][:labels].has_key? bucket_name
-                        translations[lang][:labels][bucket_name] = { }
-                    end
-
-                    # send debug message for missing translations
-                    string[lang] = ":" + string.path + ":" if string[lang].blank?
-
-                    translations[lang][:labels][bucket_name][string.label] = string[lang]
-
-                end
-
-            end
-
-            translation_files = []
-
-            # Create translations files for every available language
-            translations.each do |translation|
-
-                lang = translation[0]
-                file = translation[1][:file]
-                labels = translation[1][:labels]
-                
-                translation_files.push(file)
-
-                # creates folder and subfolders
-                FileUtils.makedirs(File.dirname(file))
-
-                # creates translation file for every available language
-                translation_file = File.new(file, "w+")
-                translation_file.write({ "#{lang.to_s}": labels}.to_yaml)
-                translation_file.close
-
-            end
-
-            LC::Response.service true, translation_files
-
-        end
-
-    end
-end

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

@@ -1,119 +0,0 @@
-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

@@ -1,97 +0,0 @@
-=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

@@ -1,215 +0,0 @@
-=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