underworld 1.0.0

data/app/controllers/underworld/dashboard_controller.rb

@@ -0,0 +1,16 @@
+require_dependency 'underworld/dashboard/application_controller'
+
+
+module Underworld
+  class DashboardController < ::Dashboard::ApplicationController
+
+    before_action :authenticate_user!, :only => [:modules, :index]
+
+    def index
+      redirect_to dashboard_path if params.include? :signin
+    end
+
+    def not_found
+    end
+  end
+end

data/app/controllers/underworld/omniauth/callbacks_controller.rb

@@ -0,0 +1,24 @@
+module Underworld
+  module Omniauth
+    class CallbacksController < Devise::OmniauthCallbacksController
+
+      # Create a method for each service you want to override
+      # If you do not provide a method a default one will used
+      # Here is facebook method for an example
+      def facebook
+        create_or_find_user
+
+        if @user.persisted?
+          sign_in_and_redirect @user, :event => :authentication #this will throw if @user is not activated
+          set_flash_message(:notice, :success, :kind => "Facebook") if is_navigational_format?
+        else
+          session["devise.facebook_data"] = request.env["omniauth.auth"]
+          redirect_to new_user_registration_url
+        end
+      end
+
+      include Underworld::Omniauth::Callbacks
+
+    end
+  end
+end

data/app/helpers/underworld/application_helper.rb

@@ -0,0 +1,4 @@
+module Underworld
+  module ApplicationHelper
+  end
+end

data/app/helpers/underworld/dashboard_helper.rb

@@ -0,0 +1,107 @@
+require_dependency 'underworld/dashboard/helpers/box_helpers'
+
+module Underworld
+  module DashboardHelper
+    include Underworld::Dashboard::Helpers::BoxHelpers
+    include ::ActionView::Helpers::TranslationHelper
+    def form_label(resource, name)
+      key = "forms.#{@resource.class.name.underscore.to_s.gsub('/', '.')}.#{name}"
+      t(key)
+    end
+
+    def localized_time(time)
+      # Fixme: Setup and use Rails l10n
+      time.strftime("%Y-%m-%d %H:%M")
+    end
+
+    def link_button(title, **options)
+      classes    = "btn pull-right btn-sm #{options.fetch(:classes, '')}"
+      icon_class = options[:icon_class]
+      href       = options.fetch(:href, '#')
+      remote     = options.fetch(:remote, false).to_s
+
+      button = "<a class='#{classes}' href='#{href}' data-remote='#{remote}'>"
+
+      if icon_class
+        button += "<i class='fa fa-#{icon_class}'></i>"
+      end
+
+      button += "<span>#{title}</span>" + '</a>'
+
+      button.html_safe
+    end
+
+    def action_buttons(buttons)
+      buttons_html = ''
+
+      buttons.each do |button|
+        href    = button.fetch(:href, '#')
+        klass   = button.fetch(:class, 'btn-success')
+        remote  = button.fetch(:remote, false).to_s
+        icons   = button.fetch(:icon_class, "")
+        label   = button.fetch(:name, '')
+        model   = button.fetch(:model, nil)
+        action  = button.fetch(:policy, nil)
+
+        with_policy(model, action) do
+          buttons_html += "<a class='action-button btn pull-right " +
+                          "#{klass}' href='#{href}' data-remote='#{remote}'"+
+                          "data-disable-with='#{spinner} #{label}'>\n" +
+                          "<i class='fa fa-#{icons}'></i>" +
+                          label +
+                          '</a>'
+        end
+      end
+      buttons_html.html_safe
+    end
+
+    # Translate route name to url dynamically
+    def get_url(route_name, id = nil, engine = Rails.application)
+      return route_name.call if id.nil?
+      return route_name.call(id) unless id.nil?
+    end
+
+    def draw_menu(menu)
+      klass = menu.class || ''
+      klass += 'treeview' if sidebar.children?
+      href  = menu.url || '#'
+
+      result = "<li class='#{klass}'> \
+            <a href='#{href}'> \
+              <i class='#{menu.icon}'></i>
+              <span>#{menu.title}</span>
+              <span class='label label-primary pull-right'>4</span>
+            </a>"
+
+      if sidebar.respond_to? :children
+        result += "<ul class='treeview-menu slide'>"
+        sidebar.children.each do |submenu|
+          result += "<li>\
+                      <a href='#{submenu.url}'>
+                        <i class='#{submenu.icon}'></i>
+                        #{submenu.title}
+                      </a>"
+          result += draw_menu submenu
+          result += '</li>'
+        end
+        result += '</ul>'
+      end
+    end
+
+    private
+
+    def spinner
+      h "<i class='fa fa-cog fa-lg fa-spin'></i>"
+    end
+
+    def with_policy(model, action, &block)
+      if model && action
+        if policy(model).send("#{action}?")
+          block.call
+        end
+      else
+        block.call
+      end
+    end
+  end
+end

data/app/helpers/underworld/groups_helper.rb

@@ -0,0 +1,4 @@
+module Underworld
+  module GroupsHelper
+  end
+end

data/app/helpers/underworld/home_helper.rb

@@ -0,0 +1,4 @@
+module Underworld
+  module HomeHelper
+  end
+end

data/app/helpers/underworld/users_helper.rb

@@ -0,0 +1,8 @@
+module Underworld
+  module UsersHelper
+    def underworldify_url(url)
+      dashboard = Underworld::Engine.dashboard_namespace
+      return url.gsub("/#{dashboard}/", "/#{dashboard}#/")
+    end
+  end
+end

data/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/underworld/concerns/assignment.rb

@@ -0,0 +1,16 @@
+module Underworld
+  module Concerns
+    # This **concern** provide the default query loading scope for model.
+    # Using this, you can make queries like key=value in http request
+    # and  Model.assignment(key: value) on you model.
+    module Assignment
+
+      def self.included(base)
+        base.scope :assignment_query, ->(field, value) do
+          base.where(field => value)
+        end
+      end
+
+    end
+  end
+end

data/app/models/underworld/concerns/user/auth_definitions.rb

@@ -0,0 +1,87 @@
+module Underworld
+  module Concerns::User::AuthDefinitions
+
+    def self.included(base)
+
+      base.class_eval do
+        # Include default devise modules. Others available are:
+        # :token_authenticatable, :confirmable,
+        # :lockable, :timeoutable and :omniauthable
+        @@devise_options = ::Underworld::Engine.devise_options
+
+        if Devise.omniauth_configs.any?
+          devise :omniauthable, :omniauth_providers => Devise.omniauth_configs.keys
+        end
+      end
+      base.extend ClassMethods
+    end
+
+    def name
+      if first_name or last_name
+        "#{first_name} #{last_name}"
+      else
+        email
+      end
+
+    end
+
+    def full_name
+      name
+    end
+
+    def admin?
+      # TODO: Find a better way to 'admin?'
+      groups.where(role: 'admin').exists?
+    end
+
+    # Confirmation not required when using omniauth
+    def confirmation_required?
+      super && identities.empty?
+    end
+
+    def update_with_password(params, *options)
+      if encrypted_password.blank?
+        update_attributes(params, *options)
+      else
+        super
+      end
+    end
+
+    # Omniauth users does not need password
+    def password_required?
+      # TODO: nil? is not suitable for here we should use empty? or blink?
+      if Devise.omniauth_configs.any?
+        return (provider.nil? || password.nil?) && super
+      else
+        password.nil? && super
+      end
+    end
+
+    module ClassMethods
+      def find_from_oauth(auth, signed_in_resource = nil)
+        user = User.where(:provider => auth.provider, :uid => auth.uid).first
+
+        first_name = auth.info.first_name
+        last_name = auth.info.last_name
+
+        if first_name.blank?
+          # With first_name being blank last_name is probably is blank too
+          name = auth.info.name.split(' ')
+          first_name = name[0]
+          last_name = name[1,] || ''
+        end
+        unless user
+          user = User.create(first_name: first_name,
+                             last_name: last_name,
+                             provider: auth.provider,
+                             uid: auth.uid,
+                             email: auth.info.email,
+                             password: Devise.friendly_token[0,20])
+        end
+        user
+      end
+
+    end
+
+  end
+end

data/app/models/underworld/concerns/user/gravatar.rb

@@ -0,0 +1,11 @@
+module Underworld
+  module Concerns::User::Gravatar
+    def gravatar
+      require 'digest/md5'
+      hash = Digest::MD5.hexdigest(email.downcase)
+
+      # compile URL which can be used in <img src="RIGHT_HERE"...
+      "http://www.gravatar.com/avatar/#{hash}"
+    end
+  end
+end

data/app/models/underworld/concerns/user/mongoid_fields.rb

@@ -0,0 +1,81 @@
+module Underworld
+  # This module contains all the **Mongoid** related definitions
+  module Concerns::User::MongoidFields
+    extend ActiveSupport::Concern
+
+    included do
+
+      field :first_name,         type: String, default: ''
+      field :last_name,          type: String, default: ''
+      field :email,              type: String, default: ''
+      field :encrypted_password, type: String, default: ''
+
+      ## Recoverable
+      field :reset_password_token,   type: String
+      field :reset_password_sent_at, type: Time
+
+      ## Recoverable
+      field :remember_created_at, type: Time
+
+      ## Trackable
+      field :sign_in_count,      type: Integer, default: 0
+      field :current_sign_in_at, type: Time
+      field :last_sign_in_at,    type: Time
+      field :current_sign_in_ip, type: String
+      field :last_sign_in_ip,    type: String
+
+
+      ## Confirmable
+      # field :confirmation_token,   type: String
+      # field :confirmed_at,         type: Time
+      # field :confirmation_sent_at, type: Time
+      # field :unconfirmed_email,    type: String # Only if using reconfirmable
+
+      # Lockable
+      field :failed_attempts, type: Integer, default: 0 # Only if lock strategy is :failed_attempts
+      field :unlock_token,    type: String # Only if unlock strategy is :email or :both
+      field :locked_at,       type: Time
+
+      # Token authenticatable
+      field :authentication_token, type: String
+
+      # run 'rake db:mongoid:create_indexes' to create indexes
+      if not Devise.omniauth_providers.empty?
+        # Service
+        field :provider, type: String, default: ''
+        field :uid,      type: String
+      end
+
+      if Rails.env.production?
+        # Confirmable
+        field :confirmation_token,   type: String
+        field :confirmed_at,         type: Time
+        field :confirmation_sent_at, type: Time
+
+        # Only if using reconfirmable
+        field :unconfirmed_email,    type: String
+      end
+
+
+      index({ email:  1 },
+            { unique: true, background: true })
+      index({ reset_password_token: 1 },
+            { unique: true, background: true })
+      index({ unlock_token: 1 },
+            { unique: true, background: true })
+      index({ authentication_token: 1 },
+            { unique: true, background: true })
+
+      # To fix the issue with new mongo
+      #def self.serialize_from_session(key, salt)
+      #  record = to_adapter.get(key[0]["$oid"])
+      #  record if record && record.authenticatable_salt == salt
+      #end
+
+      if Rails.env.production?
+        index({ confirmation_token: 1 },
+              { unique: true, background: true })
+      end
+    end
+  end
+end

data/app/models/underworld/concerns/user/permission.rb

@@ -0,0 +1,47 @@
+module Underworld
+  # This concern contains all the permission related methods
+  # to use within `Underworld::User`
+  module Concerns::User::Permission
+    extend ActiveSupport::Concern
+
+    def member_of?(group)
+      @group_ids ||= self.groups.all.map(&:id)
+      @group_ids.include? group.id
+    end
+
+    def has_permission? action, obj
+      perm = self.groups.includes(:permissions)
+        .where(underworld_permissions: { model: obj, permission_type: action })
+        .count
+      perm == 1
+    end
+
+    def can_not? action, obj
+      !has_permission? action, obj
+    end
+
+    alias_method :can?, :has_permission?
+
+    def has_ownership?(record)
+      has_permission? :ownership, record.name
+    end
+
+    def owned?(record)
+      if has_permission? :ownership, record.name
+        if record.respond_to? :user
+          return true if record.user == self
+          return false
+        end
+
+        if record.respond_to? :__owned_by
+          return true if record.__owned_by == self
+        end
+      end
+      false
+    end
+
+    def permissions
+      groups.includes(:permissions).map(&:permissions).flatten.uniq
+    end
+  end
+end

data/app/models/underworld/concerns/user/user_roles.rb

@@ -0,0 +1,24 @@
+module Underworld
+  # This concern contains all the role related methods
+  # to use within `Underworld::User`
+  module Concerns
+    module User
+      module UserRoles
+
+        # Return an array of user roles.
+        def roles
+          self.groups.to_a.map(&:role)
+        end
+
+        def role? role
+          roles.include? role.to_s
+        end
+
+        # A shortcut for `role? :admin`
+        def admin?
+          role? :admin
+        end
+      end
+    end
+  end
+end