lato_core 1.1.5 → 2.1

data/lib/lato_core/interfaces/layout.rb

@@ -0,0 +1,213 @@
+module LatoCore
+
+  # This module contains a list of functions used to mange the admin layout.
+  module Interface::Layout
+
+    # Helpers:
+
+    # This function set the current active page title on the header.
+    def core__set_header_active_page_title(title)
+      @core__header_active_page_title = title
+    end
+
+    # This function set the current active page on the menu.
+    def core__set_menu_active_item(item_key)
+      @core__menu_active_item = item_key
+    end
+
+    # Partials:
+
+    # This function returns a list of partials for the page.
+    def core__get_partials
+      lato_modules = core__get_modules_list
+      # create list of widgets
+      partials = []
+      lato_modules.each do |lato_module_name|
+        module_partials = core__get_partials_for_module(lato_module_name)
+        partials += module_partials if module_partials
+      end
+      # sort items and return them
+      partials = partials.sort_by {|partial| partial[:position]}
+      partials.reverse
+    end
+
+    # This function return the list of partials for a specific module.
+    def core__get_partials_for_module(module_name)
+      module_configs = core__get_module_configs(module_name)
+      return [] unless module_configs
+      # load module items
+      module_partials = []
+      if module_configs[:partials]
+        module_configs[:partials].each do |key, value|
+          module_partials.push(core__generate_partial(key, value, module_name))
+        end
+      end
+      # return module items
+      module_partials
+    end
+
+    # This function create a correct partial object for the header.
+    def core__generate_partial(key, values, module_name)
+      partial = {}
+      partial[:key] = key
+      partial[:path] = values[:path] ? values[:path] : ''
+      partial[:position] = values[:position] ? values[:position] : 999
+      partial
+    end
+
+    # Widgets:
+
+    # This function return a list of widgets for the header of the layout.
+    def core__get_widgets
+      lato_modules = core__get_modules_list
+      # create list of widgets
+      widgets = []
+      lato_modules.each do |lato_module_name|
+        module_widgets = core__get_widgets_for_module(lato_module_name)
+        widgets = widgets + module_widgets if module_widgets
+      end
+      # sort items and return them
+      widgets = widgets.sort_by {|widget| widget[:position]}
+      return widgets.reverse
+    end
+
+    # This function return the list of widgets for a specific module.
+    def core__get_widgets_for_module module_name
+      module_configs = core__get_module_configs(module_name)
+      return [] unless module_configs
+      # load module items
+      module_widgets = []
+      if module_configs[:widgets]
+        module_configs[:widgets].each do |key, value|
+          module_widgets.push(core__generate_widget(key, value, module_name))
+        end
+      end
+      # return module items
+      return module_widgets
+    end
+
+    # This function create a correct widget object for the header.
+    def core__generate_widget key, values, module_name
+      widget = {}
+      widget[:key] = key
+      widget[:icon] = values[:icon] ? values[:icon] : 'check-circle'
+      widget[:path] = values[:path] ? values[:path] : ''
+      widget[:position] = values[:position] ? values[:position] : 999
+      widget[:title] = values[:title] ? values[:title] : ''
+      return widget
+    end
+
+    # Menu:
+
+    # This function returns the list of the items for the menu.
+    def core__get_menu
+      lato_modules = core__get_modules_list
+      # create list of menu items
+      menu = []
+      lato_modules.each do |lato_module_name|
+        module_menu = core__get_menu_for_module(lato_module_name)
+        menu = menu + module_menu if module_menu
+      end
+      # sort items and return them
+      menu = menu.sort_by {|menu_item| [menu_item[:position], menu_item[:title]]}
+      return menu
+    end
+
+    # This function returns the list of the items for the menu for a specific module.
+    def core__get_menu_for_module module_name
+      module_configs = core__get_module_configs(module_name)
+      return [] unless module_configs
+      # load module items
+      module_menu = []
+      if module_configs[:menu]
+        module_configs[:menu].each do |key, value|
+          module_menu.push(core__generate_menu_item(key, value, module_name))
+        end
+      end
+      # return module items
+      return module_menu
+    end
+
+    # This function create a correct menu item object for the menu.
+    def core__generate_menu_item key, values, module_name
+      menu_item = {}
+      menu_item[:key] = key
+      menu_item[:title] = values[:title] ? core__get_menu_title_translation(values[:title], module_name) : 'Undefined'
+      menu_item[:icon] = values[:icon] ? values[:icon] : 'check-circle'
+      menu_item[:url] = values[:url] ? values[:url] : ''
+      menu_item[:position] = values[:position] ? values[:position] : 999
+      menu_item[:permission_min] = values[:permission_min] ? values[:permission_min] : 0
+      menu_item[:permission_max] = values[:permission_max] ? values[:permission_max] : 999
+      menu_item[:sub_items] = []
+
+      if values[:sub_items]
+        values[:sub_items].each do |key, value|
+          menu_item[:sub_items].push(core__generate_menu_sub_item(key, value, module_name))
+        end
+      end
+
+      return menu_item
+    end
+
+    # This function create a correct menu sub itam object for the menu.
+    def core__generate_menu_sub_item key, values, module_name
+      menu_sub_item = {}
+      menu_sub_item[:key] = key
+      menu_sub_item[:title] = values[:title] ? core__get_menu_title_translation(values[:title], module_name) : 'Undefined'
+      menu_sub_item[:url] = values[:url] ? values[:url] : ''
+      menu_sub_item[:permission_min] = values[:permission_min] ? values[:permission_min] : 0
+      menu_sub_item[:permission_max] = values[:permission_max] ? values[:permission_max] : 999
+      return menu_sub_item
+    end
+
+    # This function check the title name and, if it need a translaction, it return the value.
+    def core__get_menu_title_translation title, module_name
+      return title if (!title.start_with?('translate'))
+
+      title_key = core__get_string_inside_strings(title, '[', ']')
+      module_languages = core__get_module_languages(module_name)
+      return title if !module_languages || !module_languages[:menu] || !module_languages[:menu][title_key]
+
+      return module_languages[:menu][title_key]
+    end
+
+    # Assets:
+
+    # This function return an array with the list of assets for lato modules.
+    def core__get_assets
+      lato_modules = core__get_modules_list
+      # create list of menu assets
+      assets = []
+      lato_modules.each do |lato_module_name|
+        module_assets = core__get_assets_for_module(lato_module_name)
+        assets = assets + module_assets if module_assets
+      end
+      # return assets
+      return assets
+    end
+
+    # This function return the lists of assets for a specific module.
+    def core__get_assets_for_module module_name
+      module_configs = core__get_module_configs(module_name)
+      return [] unless module_configs
+      # load module assets
+      module_assets = []
+      if module_configs[:assets]
+        module_configs[:assets].each do |key, value|
+          module_assets.push(value)
+        end
+      end
+      # return module assets
+      return module_assets
+    end
+
+    # Colors:
+
+    # This function return the list of colors set for the tamplate.
+    def core__get_colors
+      core_configs = core__get_module_configs('lato_core')
+      return core_configs[:colors]
+    end
+
+  end
+end

data/lib/lato_core/interfaces/modules.rb

@@ -0,0 +1,110 @@
+module LatoCore
+  # This module contains a list of functions used to work and manage other
+  # lato modules.
+  module Interface::Modules
+
+    # Helpers:
+    ############################################################################
+
+    # This function return the root path of a specific module.
+    def core__get_module_root_path(module_name)
+      Gem.loaded_specs[module_name].full_gem_path
+    end
+
+    # This function returns the list of lato modules installed on main application.
+    def core__get_modules_list
+      all_gems = core__get_application_gems.keys
+      lato_gems = []
+      # check every gem
+      all_gems.each do |name|
+        lato_gems.push(name) if name.start_with? 'lato'
+      end
+      # return result
+      lato_gems
+    end
+
+    # Languages:
+    ############################################################################
+
+    # This function returns an object with languages for every module.
+    def core__get_modules_languages
+      lato_modules = core__get_modules_list
+      languages = {}
+      lato_modules.each do |lato_module_name|
+        languages[lato_module_name.to_sym] = core__get_module_languages(lato_module_name)
+      end
+      languages
+    end
+
+    # This function load languages for a specific module.
+    # This config are generated from the merge of application languages
+    # for the module and default languages of the module.
+    def core__get_module_languages(module_name)
+      default_languages = core__get_module_default_languages(module_name)
+      application_languages = core__get_module_application_languages(module_name)
+      return default_languages unless application_languages
+
+      default_languages.each do |key, value|
+        application_languages[key] = value unless application_languages[key]
+      end
+
+      application_languages
+    end
+
+    # This function load default languages for a specific module.
+    def core__get_module_default_languages(module_name)
+      module_root_path = core__get_module_root_path(module_name)
+      core__read_yaml("#{module_root_path}/config/languages/default.yml")
+    end
+
+    # This function load application languages for a specific module.
+    def core__get_module_application_languages(module_name)
+      application_config_path = core__get_application_lato_configs_path
+      absolute_path = "#{application_config_path}/#{module_name}_locale.yml"
+      core__read_yaml(absolute_path)
+    end
+
+    # Configs:
+    ############################################################################
+
+    # This function returns an object with configs for every module.
+    def core__get_modules_configs
+      lato_modules = core__get_modules_list
+      configs = {}
+      lato_modules.each do |lato_module_name|
+        configs[lato_module_name.to_sym] = core__get_module_configs(lato_module_name)
+      end
+      configs
+    end
+
+    # This function load configs for a specific module.
+    # This configs are generated from the merge of application configs for the module
+    # and default configs of the module.
+    def core__get_module_configs module_name
+      default_config = core__get_module_default_configs(module_name)
+      application_config = core__get_module_application_configs(module_name)
+      return default_config unless application_config
+
+      default_config.each do |key, value|
+        application_config[key] = value unless application_config[key]
+      end
+
+      return application_config
+    end
+
+    # This function load application configs for a specific module.
+    def core__get_module_application_configs module_name
+      application_config_path = core__get_application_lato_configs_path
+      absolute_path = "#{application_config_path}/#{module_name}.yml"
+      return core__read_yaml(absolute_path)
+    end
+
+    # This function load default configs for a specific module.
+    def core__get_module_default_configs module_name
+      module_root_path = core__get_module_root_path(module_name)
+      absolute_path = "#{module_root_path}/config/configs.yml"
+      return core__read_yaml(absolute_path)
+    end
+
+  end
+end

data/lib/lato_core/interfaces/token.rb

@@ -0,0 +1,25 @@
+module LatoCore
+
+  # This module contains a list of functions used to manage tokens.
+  # All functions on the module depends on 'jwt' gem.
+  module Interface::Token
+
+    # This functon return a token with encrypted payload information.
+    def core__encode_token exp, payload
+      exp = 1.day.from_now unless exp
+      payload[:exp] = exp.to_i
+      return JWT.encode(payload, Rails.application.secrets.secret_key_base)
+    end
+
+    # This function return the payload of a token.
+    def core__decode_token token
+      begin
+        body = JWT.decode(token, Rails.application.secrets.secret_key_base)[0]
+        return HashWithIndifferentAccess.new body
+      rescue => exception
+        return nil
+      end
+    end
+
+  end
+end

data/lib/lato_core/version.rb

@@ -0,0 +1,3 @@
+module LatoCore
+  VERSION = '2.1'
+end

data/lib/tasks/lato_core_tasks.rake

@@ -1,8 +1,4 @@
-include LatoCore
-
-# Initialize module on project
-desc 'Create config.yml file for Lato configuration'
-task :lato_core_initialize do
-  directory = core_getCacheDirectory
-  FileUtils.cp "#{LatoCore::Engine.root}/config/example.yml", "#{Rails.root}/config/lato/config.yml"
-end
+# desc "Explaining what the task does"
+# task :lato_core do
+#   # Task goes here
+# end

data/lib/tasks/lato_tasks.rake

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+include LatoCore::Interface
+
+desc 'Lato general tasks'
+namespace :lato do
+  desc 'Load lato modules configs on main application if they are not present'
+  task :load_configs do
+    generate_modules_application_configs(false)
+  end
+
+  desc 'Load lato modules configs on main application or rewrite them'
+  task :load_configs_forced do
+    generate_modules_application_configs(true)
+  end
+
+  desc 'Load lato modules languages on main application if they are not present'
+  task :load_languages do
+    generate_modules_application_languages('default', false)
+  end
+
+  desc 'Load lato modules languages on main application or rewrite them'
+  task :load_languages_forced do
+    generate_modules_application_languages('default', true)
+  end
+end
+
+# Load configs:
+##############################################################################
+
+# This function generates on the main application the configs files for
+# every lato module.
+def generate_modules_application_configs(forced = false)
+  lato_modules = core__get_modules_list
+  lato_modules.each do |lato_module_name|
+    generate_module_application_configs(lato_module_name, forced)
+  end
+end
+
+# This function generates on the main application the configs files for
+# a specific lato module.
+def generate_module_application_configs(module_name, forced = false)
+  # find directories path
+  application_config_path = core__get_application_lato_configs_path
+  module_root_path = core__get_module_root_path(module_name)
+  # find configs files path
+  configs_from_file_path = "#{module_root_path}/config/configs.yml"
+  config_to_file_path = "#{application_config_path}/#{module_name}.yml"
+  # copy file from module to main application (if it's possible)
+  if !forced && File.exist?(config_to_file_path)
+    puts "Already exist: #{config_to_file_path}"
+    return
+  end
+  FileUtils.cp configs_from_file_path, config_to_file_path
+  puts "Generated: #{config_to_file_path}"
+end
+
+# Load languages:
+##############################################################################
+
+def generate_modules_application_languages(language = 'default', forced = false)
+  lato_modules = core__get_modules_list
+  lato_modules.each do |lato_module_name|
+    generate_module_application_languages(lato_module_name, language, forced)
+  end
+end
+
+def generate_module_application_languages(module_name, language = 'default', forced = false)
+  # find directories path
+  application_config_path = core__get_application_lato_configs_path
+  module_root_path = core__get_module_root_path(module_name)
+  # find languages files path
+  lang_from_file_path = "#{module_root_path}/config/languages/#{language}.yml"
+  lang_from_file_path = "#{module_root_path}/config/languages/default.yml" unless File.exist?(lang_from_file_path)
+  lang_to_file_path = "#{application_config_path}/#{module_name}_locale.yml"
+  # copy file from module to main application (if it's possible)
+  if !forced && File.exist?(lang_to_file_path)
+    puts "Already exist: #{lang_to_file_path}"
+    return
+  end
+  FileUtils.cp lang_from_file_path, lang_to_file_path
+  puts "Generated: #{lang_to_file_path}"
+end