underworld 1.0.0

data/app/assets/stylesheets/underworld/simple/rtl/application.css

@@ -0,0 +1,2 @@
+//= require admin_lte/rtl/admin_lte
+//= require underworld/simple/share

data/app/assets/stylesheets/underworld/simple/rtl/rtl.scss

@@ -0,0 +1,16 @@
+@font-face {
+   font-family: 'yekan';
+   src: font-url('/fonts/BYekan.eot');
+   src: font-url("/fonts/Yekan.eot#iefix") format('embedded-opentype'),
+      font-url("/fonts/Yekan.woff") format('woff'),
+        font-url("/fonts/Yekan.ttf") format('truetype');
+}
+
+
+div, p, h1,h2,h3,h4,h5,h6,a{
+   font-family: 'yekan', tahoma;
+}
+
+.logo{
+   font-family: 'yekan', tahoma !important;
+}

data/app/assets/stylesheets/underworld/simple/share.scss

@@ -0,0 +1,11 @@
+#rememberme {
+   input {
+      display: inline;
+   }
+}
+
+.form-box {
+   .alert {
+      margin-left: 0;
+   }
+}

data/app/controllers/underworld/api_controller.rb

@@ -0,0 +1,133 @@
+require_dependency 'underworld/api_controller'
+
+module Underworld
+  # This class is the base class of all API controllers in any **Underworld**
+  # host applications. Each host Rails application should have an `APIController`
+  # which inherit from this class.
+  class APIController < Underworld::ApplicationController
+
+    # Only support `json` format
+    respond_to :json
+
+    protect_from_forgery
+    skip_before_action :verify_authenticity_token, if: :api_request?
+
+    # Authenticate user before any action take place
+    before_action :authenticate_filter
+
+    # Check for any presence of filtering query, In querystring and load
+    # resource using them
+    before_action :load_resource_by_query, :only => [:index]
+
+    # Set csrf cookie after any action
+    after_action :set_csrf_cookie_for_ng
+
+    # Rescue from any access denied exception raised from cancan and
+    # returns a useful error message in json
+    #   rescue_from CanCan::AccessDenied do |exception|
+    #     render :status => 403, :json => {
+    #       :error => t('You don\'t have access to this page'),
+    #       :orig_msg => exception.message,
+    #       :action => exception.action
+    #     }
+    #   end
+
+    def set_csrf_cookie_for_ng
+      cookies['XSRF-TOKEN'] = form_authenticity_token if protect_against_forgery?
+    end
+
+    # User authentication for API services take place here. By default
+    # **Underworld** uses the authentication method of **Devise** to authenticate
+    # access to API service.
+    #
+    # If you want to change authentication method ? just override this method
+    # in you **APIController**
+    def authenticate_filter
+      authenticate_user!
+    end
+
+    # Load resource by using parameters specified in querystring.
+    def load_resource_by_query
+      # If any query string parameter provided and allow fields specified
+      if !request.query_parameters.empty? && !allowed_fields.empty?
+
+        logger.info ('Load resource by query parameters')
+        # Iterate over parameters in query string
+        request.query_parameters.each do |key, value|
+          # each key can be like filename[__querytype]=value
+          # which `querytype` is string that specify the query type scope
+          # to use in model. For example these is a query type scope called
+          # `gt` which mean the mentioned field should be greater than the
+          # value
+          field, query_type = key.split('__')
+
+          if allowed_fields.include? field
+            # If field name is in the allowed list
+            # If no query type specified we will use assignment scope.
+            query_type = 'assignment' if query_type.nil?
+
+            # If model have an scope with the "#{query_type}_query" name.
+            # Otherwise skip
+            if model_class.respond_to? "#{query_type}_query"
+
+              # If resource already loaded. If there was a instnace variable
+              # with the plural name of the resource exists then resource
+              # already loaded and we should chain new conditions
+              if instance_variable_defined? "@#{controller_name}"
+                var = instance_variable_get("@#{controller_name}")
+                var.send("#{query_type}_query".to_sym, field, value)
+              else
+                # Resource did not loaded we make first query
+                # (without touching database) and set the corresponding
+                # instance variables
+                relation_object = model_class.send("#{query_type}_query".to_sym,
+                                                   field, value)
+                instance_variable_set("@#{controller_name}", relation_object)
+              end
+
+            else
+              logger.info "There is no `#{query_type}_query` in `#{model_class.to_s}` model."
+            end
+          else
+            logger.warn "`#{field}` in not in allowed list for `#{self.class.to_s}`."
+          end
+        end
+      else
+        logger.info('Load resource using `load_resource`')
+        #self.class.load_resource
+      end
+    end
+
+    # This attribute holds the allowed fileds which we will allow for
+    # making query
+    def allowed_fields
+      return allowed_query_on if self.respond_to?(:allowed_query_on, true)
+      @allowed_fields || []
+    end
+
+    # Using this query you can activate the query loading system
+    # and specify fields which you want to use in query loading
+    def self.allow_query_on(*args)
+      #instance_variable_set(:@allowed_fields, args.to_a.collect { |x| x.to_s })
+      define_method :allowed_query_on do
+        args.to_a.collect { |x| x.to_s }
+      end
+      private :allowed_query_on
+    end
+
+    protected
+
+    # Model class related to this controller.
+    def model_class
+      controller_name.singularize.classify.constantize
+    end
+
+    def verified_request?
+      super || form_authenticity_token == request.headers['X-XSRF-TOKEN']
+    end
+
+    def api_request?
+      request.format.json?
+    end
+  end
+end

data/app/controllers/underworld/application_controller.rb

@@ -0,0 +1,16 @@
+class Underworld::ApplicationController < ActionController::Base
+
+  include Pundit
+
+  before_action :set_locale
+
+ def set_locale
+   if I18n.available_locales.length > 1
+     lang = request.env['lang'] || params[:locale] || session[:locale] || I18n.default_locale
+   else
+     lang = I18n.default_locale
+   end
+
+   session[:locale] = I18n.locale = :"#{lang}"
+ end
+end

data/app/controllers/underworld/assets_controller.rb

@@ -0,0 +1,6 @@
+class Underworld::AssetsController < ApplicationController
+
+  include ::AMD::ControllerHelper
+  before_action :authenticate_user!
+
+end

data/app/controllers/underworld/dashboard/application_controller.rb

@@ -0,0 +1,43 @@
+require 'ostruct'
+
+module Underworld
+  module Dashboard
+    class ApplicationController < Underworld::ApplicationController
+
+      include Underworld::Dashboard::DSL
+
+      layout 'underworld/dashboard'
+
+      before_action :authenticate_user!
+      before_action :setup_sidebar
+      before_action :setup_header
+
+      rescue_from Pundit::NotAuthorizedError, with: :user_not_authorized
+      rescue_from ActiveRecord::RecordNotFound, with: :redirect_to_404
+
+      protected
+
+        def setup_header
+          @dashboard_section_title = t(controller_name.underscore)
+          @dashboard_resource_name = t(controller_name.underscore.singularize)
+          @dashboard_section_slug  = t(action_name)
+        end
+
+      private
+
+        def user_not_authorized
+          flash[:alert] = t('underworld.not_authorized')
+          redirect_to new_user_session_path
+        end
+
+        def redirect_to_404(e)
+          logger.warn "Catch and ActiveRecord::RecordNotFoundL: '#{e}'"
+
+          respond_to do |f|
+            f.html { redirect_to underworld.dashboard_not_found_url }
+            f.js { render 'underworld/dashboard/not_found' }
+          end
+        end
+    end
+  end
+end

data/app/controllers/underworld/dashboard/groups_controller.rb

@@ -0,0 +1,85 @@
+module Underworld::Dashboard
+  class GroupsController < ::Dashboard::ApplicationController
+
+    before_action :get_all_permissions, only: [:new, :edit]
+
+    def index
+      authorize Underworld::Group
+      @groups = Underworld::Group.all
+    end
+
+    def new
+      authorize Underworld::Group
+      @group = Underworld::Group.new
+    end
+
+
+    def edit
+      @group = Underworld::Group.find(params[:id])
+      authorize @group
+    end
+
+    def create
+      authorize Underworld::Group
+
+      name = group_params[:name]
+      @group = Underworld::Group.new(name: name, role: name.underscore)
+
+      @group.permissions = populate_permissions
+
+      respond_to do |f|
+        if @group.save
+          f.js
+          f.html
+        else
+          f.js { render :errors }
+          f.html
+        end
+      end
+
+    end
+
+    def update
+      @group = Underworld::Group.find(params[:id])
+      authorize @group
+      @group.permissions = populate_permissions
+      @group.name        = group_params[:name]
+      @group.role        = group_params[:name].underscore
+
+      respond_to do |f|
+        if @group.save
+          f.js
+          f.html
+        else
+          f.js { render :errors }
+          f.html
+        end
+      end
+    end
+
+    private
+
+    def populate_permissions
+      unless group_params[:permissions].nil?
+        # TODO: Fix this for mongoid too.
+        ids = group_params[:permissions].keys.map(&:to_i)
+        Underworld::Permission.where(id: ids)
+      end
+    end
+
+    def group_params
+      params.require(:group).permit!
+    end
+
+    def get_all_permissions
+      @permissions = {}
+      Underworld::Permission.all.each do |perm|
+        if @permissions.include? perm.model
+          @permissions[perm.model] << [perm.permission_type, perm.id]
+        else
+          @permissions[perm.model] = [[perm.permission_type, perm.id]]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+class Underworld::Dashboard::ProfileController < ::ApplicationController
+  layout false
+  def show
+    @user = current_user
+    respond_with(@user)
+  end
+
+  def update
+    @user = ::Underworld::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 = ::Underworld::User.find(current_user.id)
+    authorize @user
+  end
+
+  def update_password
+    @user = ::Underworld::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/underworld/dashboard/user_messages_controller.rb

@@ -0,0 +1,27 @@
+module Underworld::Dashboard
+  class UserMessagesController < ::Dashboard::ApplicationController
+
+    engine 'Underworld::Engine'
+
+    override_views :show, :new
+
+    def sent
+      authorize model
+
+      fetch_and_set_all
+      action_buttons(index_properties)
+
+      @_tools_buttons = index_properties.tool_buttons || {}
+      @resources = @resources.where(sender: current_user)
+
+      return if _override_views.include? :index
+      render 'underworld/dashboard/resource/index'
+    end
+
+    private
+
+    def index_hook(resource)
+      resource = resource.where(reciver: current_user)
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+module Underworld::Dashboard
+  class UsersController < ::Dashboard::ApplicationController
+
+    def index
+      authorize Underworld::User
+      @users = Underworld::User.all
+    end
+
+    def new
+      authorize Underworld::User
+      @user   = Underworld::User.new
+      @groups = Underworld::Group.all
+    end
+
+    def show
+      @user = Underworld::User.find(params[:id])
+      authorize @user
+    end
+
+    def edit
+      @user   = Underworld::User.find(params[:id])
+      @groups = Underworld::Group.all
+      authorize @user
+    end
+
+    def create
+
+      authorize Underworld::User
+      #group_ids = user_params[:groups]
+
+      parameters = user_params
+      groups     = parameters.delete(:groups)
+      @user = Underworld::User.new(parameters)
+      group_ids    = groups.map(&:to_i)
+      @user.groups = Underworld::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
+
+    def update
+      parameters = user_params
+      groups     = parameters.delete(:groups)
+
+
+      @user = Underworld::User.find(params[:id])
+      authorize @user
+
+      unless groups.nil?
+        group_ids    = groups.map(&:to_i)
+        @user.groups = Underworld::Group.where(id: group_ids)
+        @user.save
+      end
+
+      respond_to do |f|
+        if @user.update_without_password(parameters)
+          f.js
+          f.html
+        else
+          f.js { render :errors }
+          f.html
+        end
+      end
+    end
+
+    def edit_password
+      @user = Underworld::User.find(params[:id])
+      authorize @user, :update?
+    end
+
+    def update_password
+      @user = Underworld::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
+
+    def destroy
+      @user = Underworld::User.find(params[:id])
+      authorize @user
+
+      @user.destroy
+    end
+
+    private
+
+    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