lato_core 1.1.5 → 2.1

data/lib/generators/lato_core/templates/views/crud/new.html.erb

@@ -0,0 +1,18 @@
+<%
+  row = cell(:elements, :row).new
+  block = cell(:elements, :block).new(class: 'xs-12 sm-12 md-12')
+%>
+
+<!-- MAIN CONTAINER -->
+<%=raw row.open %>
+
+  <%=raw block.open %>
+
+    <%=raw cell(:elements, :title).new(label: 'New data', size: 2) %>
+
+    <%= render 'lato/crud/shared/form', url: lato_datas_path, method: :post %>
+
+  <%=raw block.close %>
+
+<%=raw row.close %>
+<!-- / MAIN CONTAINER -->

data/lib/generators/lato_core/templates/views/crud/shared/_form.html.erb

@@ -0,0 +1,25 @@
+<%
+  row = cell(:elements, :row).new
+  form = cell(:inputs, :form).new(url: url, method: method)
+%>
+
+<%=raw form.open %>
+
+  <%=raw row.open %>
+
+    <%=raw cell(:inputs, :text).new(name: 'data[name]', label: 'Name',
+    required: true, class: 'md-12', value: @data.name) %>
+
+  <%=raw row.close %>
+
+  <div class="text-right">
+
+    <%=raw cell(:elements, :button).new(type: 'link', label: 'Cancel',
+    style: 'danger', icon: 'ban', url: lato_datas_path) %>
+
+    <%=raw cell(:elements, :button).new(type: 'submit', label: 'Save',
+    style: 'success', icon: 'check') %>
+
+  </div>
+
+<%=raw form.close %>

data/lib/generators/lato_core/templates/views/crud/show.html.erb

@@ -0,0 +1,16 @@
+<%
+  row = cell(:elements, :row).new
+  block = cell(:elements, :block).new(class: 'xs-12 sm-12 md-12')
+%>
+
+<!-- MAIN CONTAINER -->
+<%=raw row.open %>
+
+  <%=raw block.open %>
+
+    <%=raw cell(:elements, :title).new(label: @data.name, size: 2) %>
+
+  <%=raw block.close %>
+
+<%=raw row.close %>
+<!-- / MAIN CONTAINER -->

data/lib/lato_core.rb

@@ -1,7 +1,8 @@
-module LatoCore
-
-  # include engine and interface
-  require "lato_core/engine"
-  require "lato_core/interface"
+require "lato_core/engine"
+require "lato_core/interface"
+require "lato_core/cell"
+require "lato_core/helper"
 
+module LatoCore
+  # Your code goes here...
 end

data/lib/lato_core/cell.rb

@@ -0,0 +1,28 @@
+module LatoCore
+
+  class Cell < Cell::Concept
+
+    # set cells directory
+    view_paths << "#{LatoCore::Engine.root}/app/cells"
+
+    # include cells dependencies
+    include ::Cell::Erb
+    include ActionView::Helpers::UrlHelper
+    include ActionView::Helpers::OutputSafetyHelper
+
+    # This function is used from cells to validates arguments on constructor.
+    def validate_args(args: {}, requested_args: [], default_args: {})
+      requested_args.each do |requested_arg|
+        raise "Cell must have #{requested_arg} argument" if args[requested_arg] == nil
+      end
+
+      default_args.each do |key, value|
+        args[key] = value if args[key] == nil
+      end
+
+      args
+    end
+
+  end
+
+end

data/lib/lato_core/engine.rb

@@ -2,25 +2,28 @@ module LatoCore
   class Engine < ::Rails::Engine
     isolate_namespace LatoCore
 
-    # Add migration support
-    initializer 'Add migration support' do |app|
-      unless app.root.to_s.match root.to_s
-        config.paths['db/migrate'].expanded.each do |expanded_path|
-          app.config.paths['db/migrate'] << expanded_path
-        end
-      end
-    end
+    require 'rubygems'
+    require 'sass-rails'
+    require 'uglifier'
+    require 'jquery-rails'
+    require 'cells'
+    require 'cells-erb'
+    require 'bcrypt'
+    require 'jwt'
 
-    # Add routes support
-    initializer 'Add gem routes to application',
-                before: :load_config_initializers do
+    # add routes support
+    initializer 'Add gem routes to application', before: :load_config_initializers do
       Rails.application.routes.append do
         mount LatoCore::Engine, at: '/lato/core'
       end
     end
 
-    # Add interface to main application
-    config.autoload_paths << LatoCore::Engine.root.join('lib/interface')
+     # add helpers support
+    initializer 'Add helpers to application' do
+      ActiveSupport.on_load :action_controller do
+        helper LatoCore::Helper
+      end
+    end
 
   end
 end

data/lib/lato_core/helper.rb

@@ -0,0 +1,11 @@
+module LatoCore
+  module Helper
+
+    require 'lato_core/helpers/general'
+    include LatoCore::Helper::General
+
+    require 'lato_core/helpers/cells'
+    include LatoCore::Helper::Cells
+
+  end
+end

data/lib/lato_core/helpers/cells.rb

@@ -0,0 +1,20 @@
+module LatoCore
+
+  # This module contains helpers used to manage cells.
+  module Helper::Cells
+
+    # This helper is used to create a new cell with a pretty format.
+    def cell(*names)
+      # define variables
+      names_list = names.first.to_s.start_with?('Lato') ? names[1..-1] : names
+      cell_class = names.first.to_s.start_with?('Lato') ? "#{names.first}::" : 'LatoCore::'
+      # return correct cell
+      names_list.each do |name|
+        cell_class = "#{cell_class}#{name.capitalize}::"
+      end
+      "#{cell_class}Cell".constantize
+    end
+
+  end
+
+end

data/lib/lato_core/helpers/general.rb

@@ -0,0 +1,16 @@
+module LatoCore
+
+  # This helper contain general functions.
+  module Helper::General
+
+    def erb_open_tag
+      return "<span class='erb-tag'>&#060;&#037;</span>".html_safe
+    end
+    
+    def erb_close_tag
+      return "<span class='erb-tag'>&#037;&#062;</span>".html_safe
+    end
+
+  end
+
+end

data/lib/lato_core/interface.rb

@@ -1,26 +1,29 @@
 module LatoCore
   module Interface
 
-    require 'lato_core/interface/authentication'
-    include LatoCore::Interface::Authentication
+    require 'lato_core/interfaces/general'
+    include LatoCore::Interface::General
+
+    require 'lato_core/interfaces/application'
+    include LatoCore::Interface::Application
 
-    require 'lato_core/interface/cache'
-    include LatoCore::Interface::Cache
+    require 'lato_core/interfaces/modules'
+    include LatoCore::Interface::Modules
 
-    require 'lato_core/interface/communication'
-    include LatoCore::Interface::Communication
+    require 'lato_core/interfaces/token'
+    include LatoCore::Interface::Token
 
-    require 'lato_core/interface/languages'
-    include LatoCore::Interface::Languages
+    require 'lato_core/interfaces/layout'
+    include LatoCore::Interface::Layout
 
-    require 'lato_core/interface/navigation'
-    include LatoCore::Interface::Navigation
+    require 'lato_core/interfaces/authentication'
+    include LatoCore::Interface::Authentication
 
-    require 'lato_core/interface/session'
-    include LatoCore::Interface::Session
+    require 'lato_core/interfaces/cells'
+    include LatoCore::Interface::Cells
 
-    require 'lato_core/interface/superusers'
-    include LatoCore::Interface::Superusers
+    require 'lato_core/interfaces/apihelpers'
+    include LatoCore::Interface::Apihelpers
 
   end
 end

data/lib/lato_core/interfaces/apihelpers.rb

@@ -0,0 +1,39 @@
+module LatoCore
+
+  # This module contains a list of functions used to write application or
+  # modules api. They permit to have a nice standard on api structure.
+  module Interface::Apihelpers
+
+    # This function render a normal success response with a custom payload.
+    def core__send_request_success(payload)
+      response = { result: true, error_message: nil }
+      response[:payload] = payload if payload
+      render json: response
+    end
+
+    # This function render an error message with a possible custom payload.
+    def core__send_request_fail(error, payload: nil)
+      response = { result: false, error_message: error }
+      response[:payload] = payload if payload
+      render json: response
+    end
+
+    # This function render an error message with the errors contained
+    # on an entity.
+    def core__send_entity_error(entity)
+      render_request_fail(entity.errors.full_messages.to_sentence)
+    end
+
+    # This function render an error for a bad request with an error message.
+    def core__send_bad_request_error(error)
+      render json: { result: false, error_message: error }, status: 400
+    end
+
+    # Tis function render an error for an unauthorized request with
+    # an error message.
+    def core__send_unauthorized_request_error(error)
+      render json: { result: false, error_message: error }, status: 401
+    end
+
+  end
+end

data/lib/lato_core/interfaces/application.rb

@@ -0,0 +1,65 @@
+module LatoCore
+
+  # This module contains a list of functions used to get application informations.
+  # Information about the application are saved on a global variable APPLICATION.
+  module Interface::Application
+
+    # This function return the default language set on main application (I18l).
+    def core__get_application_language
+      I18n.locale
+    end
+
+    # This function return the list of gems used by the application.
+    def core__get_application_gems
+      gems = {}
+      Bundler.load.specs.each do |spec|
+        gems[spec.name] = spec.version
+      end
+      gems
+    end
+
+    # This function return the root path of the application.
+    def core__get_application_root_path
+      Rails.root.to_s
+    end
+
+    # This function return the path of the application logo for the sidebar.
+    def core__get_application_logo_sidebar_path
+      dir = "#{core__get_application_root_path}/app/assets/images/lato/"
+      if File.exist?("#{dir}/logo_sidebar.svg")
+        return 'lato/logo_sidebar.svg'
+      elsif File.exist?("#{dir}/logo_sidebar.png")
+        return 'lato/logo_sidebar.png'
+      elsif File.exist?("#{dir}/logo_sidebar.jpg")
+        return 'lato/logo_sidebar.jpg'
+      elsif File.exist?("#{dir}/logo_sidebar.gif")
+        return 'lato/logo_sidebar.gif'
+      end
+      core__get_application_logo_path
+    end
+
+    # This function return the path of the application logo.
+    def core__get_application_logo_path
+      dir = "#{core__get_application_root_path}/app/assets/images/lato/"
+      if File.exist?("#{dir}/logo.svg")
+        return 'lato/logo.svg'
+      elsif File.exist?("#{dir}/logo.png")
+        return 'lato/logo.png'
+      elsif File.exist?("#{dir}/logo.jpg")
+        return 'lato/logo.jpg'
+      elsif File.exist?('#{dir}/logo.gif')
+        return 'lato/logo.gif'
+      end
+    end
+
+    # This function create and return the path of configs on main application.
+    def core__get_application_lato_configs_path
+      absolute_path = "#{core__get_application_root_path}/config/lato"
+      # create directory if not exist
+      FileUtils.mkdir_p(absolute_path) unless File.exist?(absolute_path)
+      # return directory
+      absolute_path
+    end
+
+  end
+end

data/lib/lato_core/interfaces/authentication.rb

@@ -0,0 +1,41 @@
+module LatoCore
+
+  # This module contains a list of functions used to authenticate a superuser.
+  module Interface::Authentication
+
+    # This function set a cookie to create the superuser session.
+    def core__create_superuser_session(superuser, lifetime)
+      token = core__encode_token(lifetime, superuser_id: superuser.id)
+      session[:lato_core__superuser_session_token] = token
+    end
+
+    # This function delete a cookie to destroy the superuser session.
+    def core__destroy_superuser_session
+      session[:lato_core__superuser_session_token] = nil
+    end
+
+    # This function tells if the current session is valid.
+    def core__check_superuser_session_valid
+      decoded_token = core__decode_token(session[:lato_core__superuser_session_token])
+      return false unless decoded_token
+      true
+    end
+
+    # This function check the session for a superuser and set the variable @core__current_superuser.
+    # If session is not valid the user should be redirect to login path.
+    def core__manage_superuser_session
+      decoded_token = core__decode_token(session[:lato_core__superuser_session_token])
+
+      if decoded_token
+        @core__current_superuser = LatoCore::Superuser.find_by(id: decoded_token[:superuser_id])
+        unless @core__current_superuser
+          core__destroy_superuser_session
+          redirect_to lato_core.login_path
+        end
+      else
+        redirect_to lato_core.login_path
+      end
+    end
+
+  end
+end

data/lib/lato_core/interfaces/cells.rb

@@ -0,0 +1,41 @@
+module LatoCore
+
+  # This module contains a list of functions used by controllers to interact with widgets
+  # cells.
+  module Interface::Cells
+
+    # This function must be executed before every action and set metadata
+    # used by cells.
+    def core__cells_initialize
+      @core__cells_authenticity_token = form_authenticity_token
+    end
+
+    # This function manage the widget index from front end.
+    def core__widgets_index(records, search: nil, pagination: 50)
+      response = {
+        records: records,
+        total: records.length,
+        per_page: pagination,
+        search: '',
+        search_key: search,
+        pagination: 1,
+      }
+      # manage search
+      if search && params[:widget_index] && params[:widget_index][:search] && !params[:widget_index][:search].blank?
+        response[:records] = response[:records].where("#{search} like ?", "%#{params[:widget_index][:search]}%")
+        response[:total] = response[:records].length
+        response[:search] = params[:widget_index][:search]
+      end
+      # manage pagination
+      if pagination
+        if params[:widget_index] && params[:widget_index][:pagination]
+          response[:pagination] = params[:widget_index][:pagination].to_i
+        end
+        response[:records] = core__paginate_array(response[:records], pagination, response[:pagination])
+      end
+      # return response
+      response
+    end
+
+  end
+end

data/lib/lato_core/interfaces/general.rb

@@ -0,0 +1,39 @@
+module LatoCore
+
+  # This module contains a list of general functions used as helpers on the system.
+  module Interface::General
+
+    # This function takes a path to a yaml file and return the hash with yaml data
+    # or nil if file not exist.
+    def core__read_yaml(file_path)
+      # return nil if file not exist
+      return unless File.exist?(file_path)
+      config_file = File.read(file_path)
+      # return yaml data
+      return YAML.safe_load(config_file).with_indifferent_access
+    rescue
+      nil
+    end
+
+    # This function return the substring inside two strings.
+    def core__get_string_inside_strings(string, marker1, marker2)
+      string[/#{Regexp.escape(marker1)}(.*?)#{Regexp.escape(marker2)}/m, 1]
+    end
+
+    # This function paginate an array and return the requested page.
+    def core__paginate_array(array, per_page, page)
+      start = (page - 1) * per_page
+      array[start, per_page]
+    end
+
+    # This function add a new GET param to an url string.
+    def core__add_param_to_url(url, param_name, param_value)
+      uri = URI(url)
+      params = URI.decode_www_form(uri.query || "") << [param_name, param_value]
+      uri.query = URI.encode_www_form(params)
+      uri.to_s
+    end
+
+  end
+
+end