lesli_babel 0.1.0

data/app/controllers/lesli_babel/translations_controller.rb

@@ -0,0 +1,134 @@
+=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 TranslationsController < ApplicationController
+        before_action :set_translation, only: []
+
+        # GET /translations
+        def index
+            #@translations = Translation.all
+        end
+
+        # GET /translations/1
+        def show
+        end
+
+        # GET /translations/new
+        def new
+            @translation = Translation.new
+        end
+
+        # GET /translations/1/edit
+        def edit
+        end
+
+        # POST /translations
+        def create
+            @translation = Translation.new(translation_params)
+
+            if @translation.save
+                redirect_to @translation, notice: "Translation was successfully created."
+            else
+                render :new
+            end
+        end
+
+        # PATCH/PUT /translations/1
+        def update
+            if @translation.update(translation_params)
+                redirect_to @translation, notice: "Translation was successfully updated."
+            else
+                render :edit
+            end
+        end
+
+        # DELETE /translations/1
+        def destroy
+            @translation.destroy
+            redirect_to translations_url, notice: "Translation was successfully destroyed."
+        end
+
+        def options
+            respond_with_successful({
+                locales_available: Lesli.config.locales
+            })
+        end
+
+        def clean
+            respond_with_successful()
+        end
+
+        def deploy
+            #TranslationsService.clean
+            TranslationsRailsService.build
+            TranslationsService.restart_server
+            respond_with_successful
+        end
+
+        def renovate
+            result = TranslationsSynchronizationService.remote_sync
+            respond_with_successful if result.success?
+            respond_with_error if not result.success?
+        end
+
+        def sync
+            result = TranslationsSynchronizationService.remote_sync true
+            respond_with_successful if result.success?
+            respond_with_error if not result.success?
+        end
+
+        def download
+
+            engine = params[:engine]
+            platform = params[:platform]
+
+            translations_result = TranslationsMiddlemanService.build(engine) if platform == "middleman"
+            translations_result = TranslationsAndroidService.build(engine) if platform == "android"
+            translations_result = TranslationsFlutterService.build(engine) if platform == "flutter"
+            translations_result = TranslationsIosService.build(engine) if platform == "ios"
+            translations_result = TranslationsJsService.build() if platform == "js"
+
+            return respond_with_error if translations_result.blank?
+
+            zip_file = "#{platform}-#{engine}-translations.zip"
+
+            LC::System::IO.zip(zip_file, translations_result.payload)
+
+            redirect_to "/tmp/#{zip_file}"
+
+        end
+
+
+        private
+
+        # Use callbacks to share common setup or constraints between actions.
+        def set_translation
+            @translation = Translation.find(params[:id])
+        end
+
+        # Only allow a trusted parameter "white list" through.
+        def translation_params
+            params.fetch(:translation, {})
+        end
+
+    end
+end

data/app/jobs/lesli_babel/application_job.rb

@@ -0,0 +1,7 @@
+module LesliBabel
+    class ApplicationJob < ActiveJob::Base
+        def perform()
+        
+        end
+    end
+end

data/app/mailers/lesli_babel/application_mailer.rb

@@ -0,0 +1,6 @@
+module LesliBabel
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/lesli_babel/application_record.rb

@@ -0,0 +1,36 @@
+=begin
+
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails SaaS Development Framework.
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+=end
+module LesliBabel
+    class ApplicationRecord < Lesli::ApplicationLesliRecord
+        self.abstract_class = true
+    end
+end

data/app/models/lesli_babel/bucket.rb

@@ -0,0 +1,6 @@
+module LesliBabel
+    class Bucket < ApplicationRecord
+        belongs_to :module
+        has_many :strings
+    end
+end

data/app/models/lesli_babel/clone.rb

@@ -0,0 +1,24 @@
+=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
+
+module LesliBabel
+    class Clone < ApplicationLesliRecord
+
+    end
+end

data/app/models/lesli_babel/dashboard.rb

@@ -0,0 +1,35 @@
+=begin
+
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails SaaS Development Framework.
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// · 
+=end
+module LesliBabel
+    class Dashboard < ApplicationRecord
+    end
+end

data/app/models/lesli_babel/module.rb

@@ -0,0 +1,35 @@
+module LesliBabel
+    class Module < ApplicationRecord
+        has_many :buckets
+
+        validates_presence_of :platform
+
+        before_create :format_module_name
+
+        def self.index 
+            Module.where("name is not null")
+            order(id: :desc).map do |translation_module|
+                {
+                    id: translation_module[:id],
+                    name: translation_module[:name],
+                    code: translation_module[:name].downcase,
+                    platform: translation_module[:platform]
+                }
+            end
+        end
+
+        def format_module_name
+
+            return if self.platform == "lesli_core"
+            return if self.platform == "lesli_engine"
+
+            self.name = self.name
+            .gsub(/[^0-9A-Za-z\s\-\_]/, '')  # remove special characters from string
+            .gsub(/-/, '')                   # replace dashes with underscore
+            .gsub(/_/, '')                   # replace underscore with underscore
+            .titlecase                       # Capitalizes all the words
+            .gsub(/\s+/, '')                 # remove blank spaces
+        end 
+
+    end
+end

data/app/models/lesli_babel/relevant.rb

@@ -0,0 +1,21 @@
+=begin
+Copyright (c) 2023, 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 Relevant < ApplicationRecord
+  end
+end

data/app/models/lesli_babel/string/activity.rb

@@ -0,0 +1,5 @@
+module LesliBabel
+    class String::Activity < CloudObject::Activity
+        belongs_to :cloud_object, class_name: "String", foreign_key: "cloud_babel_strings_id", optional: true
+    end
+end

data/app/models/lesli_babel/string/discussion.rb

@@ -0,0 +1,68 @@
+module LesliBabel
+    class String::Discussion < CloudObject::Discussion
+        belongs_to :cloud_object, class_name: "String", foreign_key: "cloud_babel_strings_id"
+        belongs_to :parent, class_name: "Discussion", optional: true
+        has_many :children, class_name: "Discussion", foreign_key: "parent_id"
+
+        def self.list(current_user, cloud_id)
+            
+            discussions = self.joins(
+                "inner join cloud_babel_strings CO on cloud_babel_string_discussions.cloud_babel_strings_id = CO.id"
+            ).joins(
+                "inner join users U on cloud_babel_string_discussions.users_id = U.id"
+            ).joins(
+                "inner join user_details UD on UD.users_id = U.id"
+            ).select(
+                "cloud_babel_string_discussions.id",
+                "cloud_babel_string_discussions.users_id",
+                "cloud_babel_string_discussions.content",
+                "cloud_babel_string_discussions.created_at",
+                "cloud_babel_string_discussions.cloud_babel_string_discussions_id",
+                "U.email",
+                "CONCAT(UD.first_name, ' ', UD.last_name) as user_name"
+            )
+            .where("CO.id = #{cloud_id}")
+            .where("CO.reference_module_bucket LIKE ?", "#{Rails.configuration.lesli_settings["instance"]}%")
+            .order(id: :asc)
+            .map { |discussion| 
+                discussion_attributes = discussion.attributes
+                discussion_attributes["created_at_raw"] = discussion_attributes["created_at"]
+                discussion_attributes["editable"] = discussion.is_editable_by?(current_user)
+                discussion_attributes["created_at"] = LC::Date.to_string_datetime(discussion_attributes["created_at"])
+                discussion_attributes
+            }
+
+            data = {}
+            root_discussions = []
+
+            # Add all responses to that discussion
+            discussions.each do |discussion|
+                discussion_data = {
+                    data: discussion,
+                    responses: []
+                }
+                data[discussion["id"]] = discussion_data
+
+                if discussion["cloud_babel_string_discussions_id"].present?
+                    parent_discussion = data[discussion["cloud_babel_string_discussions_id"]]
+                    if parent_discussion[:data]["cloud_babel_string_discussions_id"].present?
+                        discussion["response_to"] = parent_discussion[:data]["email"]
+                    end
+                    parent_discussion[:responses].push(discussion["id"])
+                else
+                    root_discussions.push(discussion_data)
+                end
+            end
+
+            # Nest the responses to root discussions. A root discussion is any comment that is not a response to another comment
+            root_discussions.each do |discussion|
+                responses = []
+                self.nest_responses(data, discussion, responses)
+                discussion[:responses] = responses
+            end
+
+            # revert the root discussions so the most recent comments appear in the top
+            root_discussions.reverse
+        end
+    end
+end

data/app/models/lesli_babel/string.rb

@@ -0,0 +1,225 @@
+module LesliBabel
+    class String < ApplicationRecord
+        belongs_to :user
+        belongs_to :bucket
+
+        before_create :clean_label_string
+
+        def self.index(current_user, query, params)
+
+            strings = TranslationsService.strings(params[:module], params[:bucket])
+
+            # if search string was sent
+            if params[:search]
+
+                search = params[:search].downcase.gsub(" ","%") 
+
+                sql_where_condition = []
+
+                # add filter to select only available languages 
+                Rails.application.config.lesli_settings["configuration"]["locales"].each do |locale|
+                    sql_where_condition.push("LOWER(#{locale}) like :search")
+                end
+
+                sql_where_condition.push("LOWER(label) like :search")
+                sql_where_condition.push("LOWER(context) like :search")
+
+                # get strings with bucket and module information
+                strings = strings.where(sql_where_condition.join(" OR "), { search: "%#{ search }%" })
+
+            end
+
+            # filters by specif ids sent as query params
+            if params["ids"]
+                ids = params["ids"].split(',').map{ |id| id.to_i }
+                strings = strings.where("cloud_babel_strings.id in (?)", ids)
+            end
+
+            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"
+            )
+
+            strings = strings
+            .page(query[:pagination][:page])
+            .per(query[:pagination][:perPage])
+            .order(:updated_at)
+
+        end
+
+
+        def self.relevant current_user, query, params
+            # relevant strings:
+            #   - missing translation for available language
+            #   - need help
+            #   - need translation
+
+            locale = query.dig(:order, :by)
+            strings = []
+            sql_where_condition = []
+
+            # add filter to select if is available language
+            if locale
+                if Rails.application.config.lesli.dig(:configuration, :locales).include?(locale.to_s)
+                    sql_where_condition.push("#{locale.to_s} is NULL")
+                    sql_where_condition.push("#{locale.to_s} = ''")
+                end
+            else
+                Rails.application.config.lesli.dig(:configuration, :locales).each do |locale|
+                    sql_where_condition.push("#{locale} is NULL")
+                    sql_where_condition.push("#{locale} = ''")
+                end
+            end
+
+            sql_where_condition.push("need_help = TRUE")
+            sql_where_condition.push("need_translation = TRUE")
+
+            strings = TranslationsService.strings.where(sql_where_condition.join(" OR ")).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"
+            )
+
+            strings
+            .page(query[:pagination][:page])
+            .per(query[:pagination][:perPage])
+            .order(query.dig(:order, :by))
+
+        end
+
+
+        
+        #######################################################################################
+        ##############################  Activities Log Methods   ##############################
+        #######################################################################################
+
+        # @return [void]
+        # @param current_user [::User] The user that created the string
+        # @param [CloudBabel::String] The string that was created
+        # @description Creates an activity for this string indicating who created it. And 
+        #   also creates an activity with the initial status of the string
+        # Example
+        #   params = {...}
+        #   string = CloudBabel::String.create(params)
+        #   CloudBabel::String.log_activity_create(User.find(1), string)
+        def self.log_activity_create(current_user, string)
+            string.activities.create(
+                user_creator: current_user,
+                category: "action_create",
+                reference_module_bucket_string: "#{string.reference_module_bucket}-#{string.label}"
+            )
+        end
+
+        # @return [void]
+        # @param current_user [::User] The user that created the string
+        # @param string [CloudBabel::String] The string that was created
+        # @param old_attributes[Hash] The data of the record before update
+        # @param new_attributes[Hash] The data of the record after update
+        # @description Creates an activity for this string if someone changed any of this values
+        # Example
+        #   string = CloudBabel::String.find(1)
+        #   old_attributes  = string.attributes.merge({detail_attributes: string.detail.attributes})
+        #   string.update(user_main: User.find(33))
+        #   new_attributes = string.attributes.merge({detail_attributes: string.detail.attributes})
+        #   CloudBabel::String.log_activity_update(User.find(1), string, old_attributes, new_attributes)
+        def self.log_activity_update(current_user, string, old_attributes, new_attributes)
+            # Bucket is a special case because it's a foreign key
+            if old_attributes["cloud_babel_buckets_id"] != new_attributes["cloud_babel_buckets_id"]
+                string.activities.create(
+                    user_creator: current_user,
+                    category: "action_update",
+                    field_name: "cloud_babel_buckets_id",
+                    value_from: Bucket.find(old_attributes["cloud_babel_buckets_id"]).name,
+                    value_to:   Bucket.find(new_attributes["cloud_babel_buckets_id"]).name
+                )
+            end
+
+            # We exclude certain keys that are not relevant
+            old_attributes.except!("id", "cloud_babe_buckets_id", "created_at", "updated_at", "deleted_at", "users_id")
+
+            old_attributes.each do |key, value|
+                if value != new_attributes[key]
+                    value_from = value
+                    value_to = new_attributes[key]
+                    value_from = LC::Date.to_string_datetime(value_from) if value_from.is_a?(Time) || value_from.is_a?(Date)
+                    value_to = LC::Date.to_string_datetime(value_to) if value_to.is_a?(Time) || value_to.is_a?(Date)
+
+                    string.activities.create(
+                        user_creator: current_user,
+                        category: "action_update",
+                        field_name: key,
+                        value_from: value_from,
+                        value_to: value_to,
+                        reference_module_bucket_string: "#{string.reference_module_bucket}-#{string.label}"
+                    )
+                end
+            end
+        end
+
+        # @return [void]
+        # @param current_user [::User] The user that created the string
+        # @param [CloudBabel::String] The string that was created
+        # @description Creates an activity for this string indicating that someone deleted it
+        # Example
+        #   string = CloudBabel::String.find(1)
+        #   CloudBabel::String.log_activity_show(User.find(1), string)
+        def self.log_activity_destroy(current_user, string)
+            string.activities.create(
+                user_creator: current_user,
+                category: "action_destroy",
+                reference_module_bucket_string: "#{string.reference_module_bucket}-#{string.label}"
+            )
+        end
+
+        def path
+            self[:engine_name]
+            .downcase
+            .sub("cloud", "")
+            .concat(".")
+            .concat(self[:bucket_name])
+            .concat(".")
+            .concat(self[:label])
+        end
+
+        private
+
+        def clean_label_string
+
+            self.label = self.label
+                .downcase                           # string to lowercase
+                .gsub(/[^0-9A-Za-z\s\-\_]/, '')     # remove special characters from string
+                .gsub(/-/, '_')                     # replace dashes with underscore
+                .gsub(/\s+/, '_')                   # replace spaces or spaces with single dash
+
+            self.status = "normal" if self.status.blank?
+            self.priority = "normal" if self.priority.blank?
+
+            self.reference_module_bucket = "#{self.bucket.reference_module}-#{self.bucket.name}"
+
+        end
+
+    end
+end

data/app/models/lesli_babel/translation.rb

@@ -0,0 +1,5 @@
+module LesliBabel
+    class Translation < ApplicationRecord
+
+    end
+end

data/app/services/lesli_babel/module_service.rb

@@ -0,0 +1,18 @@
+module LesliBabel
+    class ModuleService < Lesli::ApplicationLesliService 
+
+        def list
+
+            # get the list of installed engines, including: rails_core, rails_builder, rails_engine
+            babel_modules_names = Lesli::System.engines.map { |engine, engine_info| engine_info[:code] }
+
+            # get list of ids of installed engines and available third-party apps
+            Module
+            .where(:name => babel_modules_names) # -> only installed engines
+            #.or(Module.where.not(:platform => ["rails_core", "rails_builder", "rails_engine"]))
+            .map { |engine| engine.id } 
+            
+        end
+
+    end
+end