keppler 2.1.17 → 2.1.18

data/testing-with-2.1.18/app/models/google_analytics_setting.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# GoogleAnalyticsSetting Model
+class GoogleAnalyticsSetting < ApplicationRecord
+  belongs_to :setting
+end

data/testing-with-2.1.18/app/models/meta_tag.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+# MetaTag Model
+class MetaTag < ApplicationRecord
+  include ActivityHistory
+  include CloneRecord
+  include Uploadable
+  include Downloadable
+  include Sortable
+  acts_as_list
+  before_save :split_url
+  validates_uniqueness_of :url
+
+  validates_presence_of :title, :meta_tags, :url
+
+  def self.get_by_url(url)
+    url = url.split('//').last.split('www.').last
+    find_by_url(url)
+  end
+
+  def self.title(post_param, product_param, setting)
+    post = post_param&.title
+    product = product_param&.title || product_param&.name
+    post || product || setting.name
+  end
+
+  def self.description(post_param, product_param, setting)
+    unless post_param&.body.blank?
+      body = post_param.body
+      post = sanitize(body, tags: []).truncate(300)
+    end
+    product = product_param&.description || product_param&.body
+    post || product || setting.description
+  end
+
+  def self.image(request, post_param, product_param, setting_param)
+    post = post_param&.image
+    product = product_param&.image || product_param&.photo
+    setting = setting_param&.logo unless setting_param&.logo.blank?
+    image = '/assets/admin/slice.png'
+    url = request.protocol + request.host_with_port
+    url + (post || product || setting || image).to_s
+  end
+
+  def self.search_field
+    :title_or_description_or_url_cont_any
+  end
+
+  private
+
+  def split_url
+    self.url = url.split('//').last.split('www.').last
+  end
+end

data/testing-with-2.1.18/app/models/permission.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Permission
+class Permission < ApplicationRecord
+  belongs_to :role
+end

data/testing-with-2.1.18/app/models/rocket.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+# Rocket Model
+class Rocket < ApplicationRecord
+  # Rockets list
+  def self.names_list
+    Dir["#{Rails.root}/rockets/*"].map do |dir|
+      rocket_name = dir.split('/').last
+      dir_size = 0
+      Dir.glob("#{dir}/**/**").map do |file|
+        dir_size += File.size(file)
+      end
+      "#{rocket_name} (#{filesize(dir_size)})"
+    end
+  end
+
+  # Create rocket
+  def self.new_rocket(rocket)
+    system "rails g new_rocket #{rocket}"
+  end
+
+  # Catching rocket file and saving in public/rockets
+  def self.save_and_rename(rocket_file)
+    dir = Rails.root.join('public', 'rockets')
+    Dir.mkdir(dir) unless Dir.exist?(dir)
+    tmp = rocket_file.tempfile
+    destiny_file = File.join("#{Rails.root}/public/rockets")
+    FileUtils.move tmp.path, destiny_file
+    File.rename(
+      "#{destiny_file}/#{tmp.path.split('/')[-1]}",
+      "#{destiny_file}/#{rocket_file.original_filename}"
+    )
+  end
+
+  # Unzipping into rockets folder
+  def self.unzip(rocket_file, rocket_name)
+    require 'zip'
+    rocket_zip = "#{Rails.root}/public/rockets/#{rocket_file.original_filename}"
+    Zip::File.open(rocket_zip) do |zip_file|
+      dir = Rails.root.join('rockets', rocket_name)
+      Dir.mkdir(dir) unless Dir.exist?(dir)
+      uncompress_pkg(zip_file, rocket_name)
+    end
+  end
+
+  # Installing rocket
+  def self.install(rocket_name)
+    system "rails g install_rocket #{rocket_name}"
+  end
+
+  # Uninstall rocket
+  def self.uninstall(rocket_name)
+    system "rails g uninstall_rocket #{rocket_name}"
+  end
+
+  # Build rocket
+  def self.build(rocket)
+    rocket_dir = "#{Rails.root}/rockets/#{rocket}"
+    Dir.mkdir("#{rocket_dir}/pkg") unless Dir.exist?("#{rocket_dir}/pkg")
+    compress_pkg(rocket_dir)
+    public_rockets = "#{Rails.root}/public/rockets"
+    Dir.mkdir(public_rockets) unless Dir.exist?(public_rockets)
+    system "cp #{rocket_dir}/pkg/#{rocket}.rocket #{public_rockets}"
+  end
+
+  # private
+
+  def self.compress_pkg(rocket_dir)
+    archive = "#{rocket_dir}/pkg/#{File.basename(rocket_dir)}.rocket"
+    require 'zip'
+    return if File.exist? archive
+    Zip::File.open(archive, 'w') do |zipfile|
+      Dir["#{rocket_dir}/**/**"].reject { |f| f.eql? archive }.each do |file|
+        zipfile.add(file.sub(rocket_dir + '/', ''), file)
+      end
+    end
+  end
+
+  def self.uncompress_pkg(zip_file, rocket_name)
+    zip_file.each do |entry|
+      unless File.exist?("#{Rails.root}/rockets/#{rocket_name}/#{entry.name}")
+        puts "*** Extracting #{entry.name} ***"
+        entry.extract("#{Rails.root}/rockets/#{rocket_name}/#{entry.name}")
+      end
+    end
+  end
+
+  def self.filesize(size)
+    units = %w[B KB MB GB TB Pb EB]
+    return '0.0 B' if size.zero?
+    exp = (Math.log(size) / Math.log(1024)).to_i
+    exp = 6 if exp > 6
+    [(size.to_f / 1024**exp).round(2), units[exp]].join(' ')
+  end
+
+  def self.parse_name(rocket_name)
+    rocket_name
+      .remove(':', ';', '\'', '"')
+      .downcase
+      .parameterize
+      .dasherize
+      .remove('keppler-')
+      .underscore
+  end
+end

data/testing-with-2.1.18/app/models/role.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+# Role model
+class Role < ApplicationRecord
+  #
+  # include Recoverable
+  #
+  # before_create -> { create_yml('role') }
+  # # before_destroy -> { update_yml('role') }
+
+  has_and_belongs_to_many :users, join_table: :users_roles
+  belongs_to :resource,
+             polymorphic: true,
+             optional: true,
+             dependent: :destroy
+  validates :resource_type,
+            inclusion: { in: Rolify.resource_types },
+            allow_nil: true
+  scopify
+  validates_presence_of :name
+  validates_uniqueness_of :name
+  has_many :permissions, dependent: :destroy
+
+  def self.search_field
+    :name_cont
+  end
+
+  # def destroy_yml_file
+  #   destroy_yml('role')
+  # end
+
+  def permissions?
+    !permissions.empty?
+  end
+
+  def all_permissions
+    permissions.first&.modules
+  end
+
+  def permission_to(module_name)
+    !all_permissions&.dig(module_name).nil? || false
+  end
+
+  def action?(module_name, action)
+    permit = all_permissions
+    return unless permit && !permit[module_name].nil?
+    permit[module_name]['actions'].include?(action)
+  end
+
+  def include_actions?(module_name, actions)
+    permit = all_permissions
+    return unless permit && !permit[module_name].nil?
+    permit[module_name]['actions'] & actions
+  end
+
+  def toggle_actions(module_name, action)
+    if permission_to(module_name)
+      update_action(module_name, action)
+    else
+      add_module(module_name, action)
+    end
+  end
+
+  def toggle_all_actions(module_name, actions)
+    if permission_to(module_name)
+      update_actions(module_name, actions)
+    else
+      add_module(module_name, actions)
+    end
+  end
+
+  def all_actions?(module_name, actions)
+    return unless permission_to(module_name)
+    permit = all_permissions[module_name]['actions'].reject(&:empty?)
+    permit.blank? ? false : permit.uniq.length.eql?(actions&.uniq&.length)
+  end
+
+  def first_permission(module_name, action)
+    Permission.create(
+      role_id: id,
+      modules: Hash[module_name, Hash['actions', Array(action)]]
+    )
+  end
+
+  def add_module(module_name, action)
+    old_hash = all_permissions
+    new_hash = Hash[module_name, Hash['actions', Array(action)]]
+    permissions.first.update(modules: old_hash.merge(new_hash))
+  end
+
+  private
+
+  def add_action(module_name, action)
+    permission = permissions.first
+    permission.update(modules: create_hash('add', module_name, action))
+  end
+
+  def remove_action(module_name, action)
+    permission = permissions.first
+    permission.update(modules: create_hash('remove', module_name, action))
+  end
+
+  def update_action(module_name, action)
+    if action?(module_name, action)
+      remove_action(module_name, action)
+    else
+      add_action(module_name, action)
+    end
+  end
+
+  def update_actions(module_name, actions)
+    if all_actions?(module_name, actions) || actions.blank?
+      clear_actions(module_name)
+    else
+      actions&.each { |act| add_action(module_name, act) }
+    end
+  end
+
+  def clear_actions(module_name)
+    old_hash = all_permissions
+    new_hash = Hash[module_name, Hash['actions', []]]
+    permissions.first.update(modules: old_hash.merge(new_hash))
+  end
+
+  def create_hash(act, module_name, action)
+    old_hash = all_permissions
+    arr = old_hash.dig(module_name, 'actions')
+
+    act.eql?('add') ? arr.push(action) : arr.delete_if { |a| a.eql?(action) }
+
+    new_hash = Hash[module_name, Hash['actions', arr]]
+    old_hash.merge(new_hash)
+  end
+end

data/testing-with-2.1.18/app/models/script.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# Script Model
+class Script < ApplicationRecord
+  include ActivityHistory
+  include CloneRecord
+  include Uploadable
+  include Downloadable
+  include Sortable
+  acts_as_list
+
+  validates_presence_of :name, :script, :url
+
+  def self.get_script(request)
+    find_by_url(request.url)
+  end
+
+  def self.search_field
+    :name_or_script_cont
+  end
+end

data/testing-with-2.1.18/app/models/seo.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# Seo Model
+class Seo < ApplicationRecord
+  include ActivityHistory
+  include CloneRecord
+  include Uploadable
+  include Downloadable
+  include Sortable
+  acts_as_list
+  acts_as_paranoid
+
+  # Fields for the search form in the navbar
+  def self.search_field
+    fields = %i[position deleted_at]
+    build_query(fields, :or, :cont)
+  end
+
+  # Funcion para armar el query de ransack
+  def self.build_query(fields, operator, conf)
+    query = fields.join("_#{operator}_")
+    query << "_#{conf}"
+    query.to_sym
+  end
+
+  def self.sitemap_code
+    file = "#{Rails.root}/config/sitemap.rb"
+    index_html = File.readlines(file)
+    index_html.join('')
+  end
+
+  def self.robots_code
+    file = "#{Rails.root}/public/robots.txt"
+    index_html = File.readlines(file)
+    index_html.join('')
+  end
+
+  def self.save_sitemap(code)
+    file = "#{Rails.root}/config/sitemap.rb"
+    File.write(file, code)
+
+    system "ruby #{Rails.root}/config/sitemap.rb"
+  end
+
+  def self.save_robots(code)
+    file = "#{Rails.root}/public/robots.txt"
+    File.write(file, code)
+  end
+end

data/testing-with-2.1.18/app/models/setting.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Setting Model
+class Setting < ApplicationRecord
+  include ActivityHistory
+
+  has_one :smtp_setting, dependent: :destroy
+  has_one :google_analytics_setting, dependent: :destroy
+  has_one :social_account, dependent: :destroy
+  has_one :appearance, dependent: :destroy
+
+  accepts_nested_attributes_for(
+    :smtp_setting, :google_analytics_setting,
+    :social_account, :appearance
+  )
+
+  mount_uploader :favicon, AttachmentUploader
+  mount_uploader :logo, AttachmentUploader
+end

data/testing-with-2.1.18/app/models/smtp_setting.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# SmtpSetting Model
+class SmtpSetting < ApplicationRecord
+  belongs_to :setting
+  validates_presence_of :address, :port, :domain_name, :email, :password
+end

data/testing-with-2.1.18/app/models/social_account.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# SocialAccount Model
+class SocialAccount < ApplicationRecord
+  belongs_to :setting
+end

data/testing-with-2.1.18/app/models/user.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# User Model
+class User < ApplicationRecord
+  include ActivityHistory
+  # mount_uploader :avatar, TemplateUploader
+  before_save :create_permalink, if: :new_record?
+  rolify
+  validates_presence_of :name, :role_ids, :email
+  mount_uploader :avatar, AttachmentUploader
+  acts_as_paranoid
+
+  # Include default devise modules. Others available are:
+  # :confirmable, :lockable, :timeoutable and :omniauthable
+  devise :database_authenticatable, :registerable,
+         :recoverable, :rememberable, :trackable, :validatable
+
+  def rol
+    roles&.first&.name || 'default'
+  end
+
+  def permissions?
+    roles&.first&.permissions?
+  end
+
+  def allowed_modules
+    array = permissions&.map do |k, v|
+      k.split('_').join('').downcase unless v['actions'].blank?
+    end
+    array&.compact unless array.nil?
+  end
+
+  def allowed_action?(arr, arr2)
+    !(arr && arr2).nil?
+  end
+
+  def self.filter_by_role(obj, role_id)
+    obj.select { |u| u.rol.eql?(role_id) }
+  end
+
+  # Get the page number that the object belongs to
+  def page(order = :id)
+    ((self.class.order(order => :desc)
+      .pluck(order).index(send(order)) + 1)
+        .to_f / self.class.default_per_page).ceil
+  end
+
+  def self.search_field
+    :name_or_username_or_email_cont
+  end
+
+  def keppler_admin?
+    rol.eql?('keppler_admin')
+  end
+
+  def admin?
+    rol.eql?('admin')
+  end
+
+  def can?(model_name, method)
+    return if permissions.nil? || permissions[model_name].nil?
+    permissions[model_name]['actions'].include?(method) || false
+  end
+
+  def permissions
+    return if roles.first.permissions.blank?
+    roles.first.permissions.first.modules
+  end
+
+  private
+
+  def create_permalink
+    self.permalink = name.downcase.parameterize + '-' + SecureRandom.hex(4)
+  end
+end