faalis 1.0.0 → 2.0.0.rc2

data/app/controllers/faalis/dashboard/profile_controller.rb

@@ -0,0 +1,49 @@
+class Faalis::Dashboard::ProfileController < ::ApplicationController
+  layout false
+  def show
+    @user = current_user
+    respond_with(@user)
+  end
+
+  def update
+    @user = ::Faalis::User.find(current_user.id)
+    authorize @user
+    respond_to do |f|
+      if @user.update_without_password(resource_params)
+        f.js { }
+        f.html { }
+      else
+        @errors = @user.errors
+        f.js {render :errors}
+        f.html
+      end
+    end
+
+  end
+
+
+  # GET /sites/new
+  def edit_password
+    @user = ::Faalis::User.find(current_user.id)
+    authorize @user
+  end
+
+  def update_password
+    @user = ::Faalis::User.find(current_user.id)
+    authorize @user
+    respond_to do |f|
+      if @user.update_with_password(resource_params)
+        f.js { redirect_to new_user_session_path }
+        f.html { redirect_to new_user_session_path }
+      else
+        @errors = @user.errors
+        f.js {render :errors}
+        f.html
+      end
+    end
+  end
+
+  def resource_params
+    params.require(:user).permit(:password, :current_password, :password_confirmation, :first_name, :last_name, :email)
+  end
+end

data/app/controllers/faalis/dashboard/users_controller.rb

@@ -1,100 +1,110 @@
-class Faalis::Dashboard::UsersController < ::ApplicationController
-  layout false
+module Faalis::Dashboard
+  class UsersController < ::Dashboard::ApplicationController
 
-  def index
-    authorize Faalis::User
-    @users = Faalis::User.all
-  end
-
-  def new
-    authorize Faalis::User
-    @user   = Faalis::User.new
-    @groups = Faalis::Group.all
-  end
-
-  def show
-    @user = Faalis::User.find(params[:id])
-    authorize @user
-  end
+    def index
+      authorize Faalis::User
+      @users = Faalis::User.all
+    end
 
-  def edit
-    @user   = Faalis::User.find(params[:id])
-    @groups = Faalis::Group.all
-    authorize @user
-  end
+    def new
+      authorize Faalis::User
+      @user   = Faalis::User.new
+      @groups = Faalis::Group.all
+    end
 
-  def create
-    authorize Faalis::User
-    group_ids = user_params[:groups]
+    def show
+      @user = Faalis::User.find(params[:id])
+      authorize @user
+    end
 
-    @user = Faalis::User.new(user_params)
-    @user.groups = Faalis::Group.where(id: group_ids)
+    def edit
+      @user   = Faalis::User.find(params[:id])
+      @groups = Faalis::Group.all
+      authorize @user
+    end
 
-    respond_to do |f|
-      if @save.save
-        f.js
-        f.html
-      else
-        f.js { render :errors }
-        f.html
+    def create
+      authorize Faalis::User
+      group_ids = user_params[:groups]
+
+      @user = Faalis::User.new(user_params)
+      @user.groups = Faalis::Group.where(id: group_ids)
+
+      respond_to do |f|
+        if @user.save
+          f.js
+          f.html
+        else
+          f.js { render :errors }
+          f.html
+        end
       end
     end
-  end
-
-  def update
-    parameters = user_params
-    group_ids  = parameters.delete(:groups).map(&:to_i)
 
-    @user = Faalis::User.find(params[:id])
-    authorize @user
-
-    @user.groups = Faalis::Group.where(id: group_ids)
-    @user.save
-
-    respond_to do |f|
-      if @user.update_without_password(parameters)
-        f.js
-        f.html
-      else
-        f.js { render :errors }
-        f.html
+    def update
+      puts "---", user_params
+      parameters = user_params
+      #groups     = parameters.delete(:groups)
+      group_ids  = parameters.delete(:groups).map(&:to_i)
+
+      @user = Faalis::User.find(params[:id])
+      authorize @user
+
+      @user.groups = Faalis::Group.where(id: group_ids)
+      @user.save
+
+      respond_to do |f|
+        if @user.update_without_password(parameters)
+          f.js
+          f.html
+        else
+          f.js { render :errors }
+          f.html
+        end
       end
     end
-  end
 
-  def edit_password
-    @user = Faalis::User.find(params[:id])
-    authorize @user, :update?
-  end
+    def edit_password
+      @user = Faalis::User.find(params[:id])
+      authorize @user, :update?
+    end
 
-  def update_password
-    @user = Faalis::User.find(params[:id])
-    authorize @user, :update?
-
-    respond_to do |f|
-      if @user.update(password_params)
-        f.js
-        f.html
-      else
-        f.js { render :errors }
-        f.html
+    def update_password
+      @user = Faalis::User.find(params[:id])
+      authorize @user, :update?
+
+      respond_to do |f|
+        if @user.update(password_params)
+          f.js
+          f.html
+        else
+          f.js { render :errors }
+          f.html
+        end
       end
     end
-  end
 
-  def destroy
-  end
+    def destroy
+      @user = Faalis::User.find(params[:id])
+      authorize @user
 
-  private
+      @user.destroy
+    end
 
-  def password_params
-    params.require(:user).permit(:password, :password_confirmation)
-  end
+    private
 
-  def user_params
-    params.require(:user).permit(:first_name,
-                                 :last_name,
-                                 :email,
-                                 groups: [])
+    def password_params
+      params.require(:user).permit(:password, :password_confirmation)
+    end
+
+    def user_params
+      params[:user][:groups] ||= []
+      params.require(:user).permit(:first_name,
+                                   :last_name,
+                                   :email,
+                                   :password,
+                                   :password_confirmation,
+                                   :groups => [])
+    end
   end
 end

data/app/controllers/faalis/dashboard_controller.rb

@@ -1,63 +1,16 @@
-require_dependency 'faalis/application_controller'
+require_dependency 'faalis/dashboard/application_controller'
 
 
 module Faalis
-  class DashboardController < ApplicationController
+  class DashboardController < ::Dashboard::ApplicationController
 
-    include Faalis::Dashboard::Controller
-
-    layout 'faalis/dashboard'
     before_filter :authenticate_user!, :only => [:modules, :index]
 
-    respond_to :json, :html
-
-    def jstemplate
-      if user_signed_in?
-
-        js_template = 'JS_TEMPLATE'
-        js_template.yellow if String.respond_to? :colorize
-
-        logger.info "#{js_template}: angular/#{params[:path]}"
-        render template: "angular/#{params[:path]}", layout: nil
-      else
-        render :login_required_page
-      end
-    end
-
     def index
       redirect_to dashboard_path if params.include? :signin
-      @jstemplates_path = '/templates'
     end
 
-    def modules
-      dashboard_modules = []
-      Faalis::Engine.dashboard_modules.each do |module_name, attrs|
-
-        attrs[:title] = _(module_name.to_s) if not attrs.include? :title
-        attrs[:resource] = module_name.to_s if not attrs.include? :resource
-
-        # If class did not given by user in settings
-        # Faalis tries to guess the class name
-        if not attrs.include? :model
-          begin
-            klass = attrs[:resource].camelize.constantize
-
-            if klass.respond_to? :possible_permissions
-              attrs[:model] = attrs[:resource].camelize
-            else
-              attrs[:model] = ""
-            end
-
-          rescue NameError
-            attrs[:model] = ""
-          end
-        end
-
-        dashboard_modules << attrs
-      end
-      dashboard_modules = {:modules => dashboard_modules}
-      respond_with dashboard_modules
+    def not_found
     end
   end
-
 end

data/app/helpers/faalis/dashboard_helper.rb

@@ -1,5 +1,42 @@
 module Faalis
   module DashboardHelper
 
+    def localized_time(time)
+      # Fixme: Setup and use Rails l10n
+      time.strftime("%Y-%m-%d %H:%M")
+    end
+
+    # Translate route name to url dynamically
+    def get_url(route_name, id = nil, engine = Rails.application)
+      return engine.routes.url_helpers.send(route_name, id.to_s) unless id.nil?
+      engine.routes.url_helpers.send(route_name)
+    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
   end
 end

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

@@ -0,0 +1,11 @@
+module Faalis
+  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/faalis/permission.rb

@@ -27,7 +27,8 @@ module Faalis
     #alias_method :action, :permission_type
 
     def to_s
-      _("can %s %s") % [_(self.permission_type.to_s), self.model.underscore.humanize]
+      t('permission_string', action: t(self.permission_type.to_s),
+        model: t(self.model.underscore.humanize))
     end
 
     def id_repr

data/app/models/faalis/user.rb

@@ -44,6 +44,9 @@ module Faalis
     # Roles related methods for user
     include Faalis::Concerns::User::UserRoles
 
+    # Gravatar
+    include Faalis::Concerns::User::Gravatar
+
     # Make this model authorizable
     include Faalis::Concerns::Authorizable