my_admin 0.0.2

data/app/helpers/my_admin_field_helper.rb

@@ -0,0 +1,179 @@
+# -*- coding: utf-8 -*-
+module MyAdminFieldHelper
+  
+  def fieldset_title(application, model, fieldset)
+    I18n.t!("activerecord.fieldsets.#{model.i18n}.#{fieldset.to_s}") rescue fieldset.to_s
+  end
+  
+  def field_can_order(application, model, field)
+    order = field_setting(model, field, :order)
+    (order.nil? or order)
+  end
+  
+  def field_title(model, field)
+    #I18n.t!("activerecord.attributes.#{model.i18n}.#{field}") rescue field.to_s.titleize
+    model.human_attribute_name(field)
+  end
+  
+  def field_collection(application, model, field, object)
+    block = field_setting(model, field, :collection)
+    unless block.blank?
+      collection  = instance_exec object, &(block) 
+    else
+  	  collection ||= model.reflections[field.to_sym].klass.all.map { |i| [i.to_s, i.id] } unless model.reflections[field.to_sym].blank?
+    end
+  	collection ||= []
+  	collection
+  end
+  
+  def field_hint(application, model, field, type)
+    content_tag(:code, I18n.t!("activerecord.hint.#{model.i18n}.#{field}.#{type}"), :class => "help-block") rescue ""
+  end
+  
+  def field_setting(model, field, setting)
+    if model.my_admin.fields.has_key? field.to_sym
+      if model.my_admin.fields[field.to_sym].has_key? setting.to_sym
+        model.my_admin.fields[field.to_sym][setting.to_sym]
+      end
+    end
+  end
+  
+  def field_type(application, model, field, object = nil)
+    
+    column = model.columns.find{ |c| c.name == field.to_s }
+
+    object_type = object.send(field).class.name.underscore unless object.blank?
+    object_type = column.type unless column.blank?
+    object_type = model.reflections[field.to_sym].macro if model.reflections.has_key? field.to_sym
+    object_type = field_setting(model, field, :type) unless field_setting(model, field, :type).blank?
+    object_type
+    
+  end
+  
+  def filter_field_type(application, model, field, object = nil)
+    
+    column = model.columns.find{ |c| c.name == field.to_s }
+
+    object_type = object.send(field).class.name.underscore unless object.blank?
+    object_type = column.type unless column.blank?
+    object_type = model.reflections[field.to_sym].macro if model.reflections.has_key? field.to_sym
+    object_type = field_setting(model, field, :type) unless field_setting(model, field, :type).blank?
+    object_type = field_setting(model, field, :filter_type) unless field_setting(model, field, :filter_type).blank?
+    object_type
+    
+  end
+  
+  def edit_field_struct(application, model, field, object, form, show_label=true)
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/edit/#{field}_struct"
+    template = "my_admin/#{application.key}/fields/edit/#{field}_struct" unless lookup_context.exists? template
+    template = "my_admin/fields/edit/#{field}_struct" unless lookup_context.exists? template
+    
+    object_type = field_type(application, model, field, object)
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/edit/type/#{object_type}_struct" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/edit/type/#{object_type}_struct" unless lookup_context.exists? template
+    template = "my_admin/fields/edit/type/#{object_type}_struct" unless lookup_context.exists? template
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/edit/type/default_struct" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/edit/type/default_struct" unless lookup_context.exists? template
+    template = "my_admin/fields/edit/type/default_struct" unless lookup_context.exists? template
+
+    render :template => template, :locals => {:show_label => show_label, :application => application, :model => model, :field => field, :object => object, :form => form }
+  end
+  
+  def field_content(application, model, field, object)
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/#{field}"
+    template = "my_admin/#{application.key}/fields/#{field}" unless lookup_context.exists? template
+    template = "my_admin/fields/#{field}" unless lookup_context.exists? template
+    
+    object_type = field_type(application, model, field, object)
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/type/#{object_type}" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/type/#{object_type}" unless lookup_context.exists? template
+    template = "my_admin/fields/type/#{object_type}" unless lookup_context.exists? template
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/type/default" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/type/default" unless lookup_context.exists? template
+    template = "my_admin/fields/type/default" unless lookup_context.exists? template
+    
+    render :template => template, :locals => {:application => application, :model => model, :field => field, :object => object }
+  end
+  
+  def edit_field_content(application, model, field, object, form)
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/edit/#{field}"
+    template = "my_admin/#{application.key}/fields/edit/#{field}" unless lookup_context.exists? template
+    template = "my_admin/fields/edit/#{field}" unless lookup_context.exists? template
+    
+    object_type = field_type(application, model, field, object)
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/edit/type/#{object_type}" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/edit/type/#{object_type}" unless lookup_context.exists? template
+    template = "my_admin/fields/edit/type/#{object_type}" unless lookup_context.exists? template
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/edit/type/default" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/edit/type/default" unless lookup_context.exists? template
+    template = "my_admin/fields/edit/type/default" unless lookup_context.exists? template
+
+    render :template => template, :locals => {:application => application, :model => model, :field => field, :object => object, :form => form }
+  end
+  
+  def filter_field_struct(application, model, field, object, show_label=true)
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/filter/#{field}_struct"
+    template = "my_admin/#{application.key}/fields/filter/#{field}_struct" unless lookup_context.exists? template
+    template = "my_admin/fields/filter/#{field}_struct" unless lookup_context.exists? template
+    
+    object_type = filter_field_type(application, model, field, object)
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/filter/type/#{object_type}_struct" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/filter/type/#{object_type}_struct" unless lookup_context.exists? template
+    template = "my_admin/fields/filter/type/#{object_type}_struct" unless lookup_context.exists? template
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/filter/type/default_struct" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/filter/type/default_struct" unless lookup_context.exists? template
+    template = "my_admin/fields/filter/type/default_struct" unless lookup_context.exists? template
+
+    render :template => template, :locals => {:show_label => show_label, :application => application, :model => model, :field => field, :object => object }
+  end
+  
+  def filter_field_content(application, model, field, object)
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/filter/#{field}"
+    template = "my_admin/#{application.key}/fields/filter/#{field}" unless lookup_context.exists? template
+    template = "my_admin/fields/filter/#{field}" unless lookup_context.exists? template
+    
+    object_type = filter_field_type(application, model, field, object)
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/filter/type/#{object_type}" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/filter/type/#{object_type}" unless lookup_context.exists? template
+    template = "my_admin/fields/filter/type/#{object_type}" unless lookup_context.exists? template
+    
+    template = "my_admin/#{application.key}/#{model.model_tableize}/fields/filter/type/default" unless lookup_context.exists? template
+    template = "my_admin/#{application.key}/fields/filter/type/default" unless lookup_context.exists? template
+    template = "my_admin/fields/filter/type/default" unless lookup_context.exists? template
+
+    render :template => template, :locals => {:application => application, :model => model, :field => field, :object => object }
+  end
+  
+  def config_field_content(configuration)
+    template = "my_admin/fields/config/#{configuration.key}"
+    template = "my_admin/fields/config/type/#{configuration.field_type}" unless lookup_context.exists? template
+    template = "my_admin/fields/config/type/default" unless lookup_context.exists? template
+
+    render :template => template, :locals => {:configuration => configuration}
+  end
+  
+  def filter_filter(application, model, field, objects)
+    
+    if @objects.respond_to? "my_admin_filter_#{field}"
+      @objects = @objects.send("my_admin_filter_#{field}", params[@model.underscore])
+    else
+      object_type = filter_field_type(application, model, field)
+      if @objects.respond_to? "my_admin_filter_type_#{object_type}"
+        @objects.send("my_admin_filter_type_#{object_type}", @model, field, params[@model.underscore])
+      else
+        @objects = @objects.my_admin_filter(@model, field, params[@model.underscore])
+      end
+    end
+    
+  end
+  
+end

data/app/helpers/my_admin_helper.rb

@@ -0,0 +1,35 @@
+module MyAdminHelper
+
+  include MyAdminSessionHelper
+  include MyAdminApplicationHelper
+  include MyAdminModelHelper
+  include MyAdminFieldHelper
+  include MyAdminLogHelper
+  include AssetPackageHelper
+  
+  def admin_prefix
+    @admin_prefix ||= MyAdmin.url_prefix
+  end
+  
+  def my_admin_format_number (value, options={})
+    number_to_currency(value, {:format => "%u %n", :separator => ",", :delimiter => ".", :unit => "", :precision => 0 }.update(options))
+  end
+  
+  def my_admin_number_to_currency (value, options={})
+    number_to_currency(value, {:format => "%u %n", :separator => ",", :delimiter => ".", :unit => ""}.update(options))
+  end
+  
+  def my_admin_number_to_currency_edit ( number, unit="", precision=2 )
+    number_to_currency(number, :unit => unit, :separator => ".", :delimiter => "", :format => "%n", :precision => precision)
+  end
+  
+  def set_my_admin_cache_params(par) 
+    cookies.permanent.signed["#{Rails.application.class.parent_name.downcase}_my_admin_cache_params"] = par.to_s
+  end
+  
+  def my_admin_cache_params
+    ret = cookies.signed["#{Rails.application.class.parent_name.downcase}_my_admin_cache_params"] || {}
+    eval(ret)
+  end
+  
+end

data/app/helpers/my_admin_log_helper.rb

@@ -0,0 +1,7 @@
+module MyAdminLogHelper
+  
+  def create_log(user, application, mdl, item, action)
+    MyAdmin::Log.create(:user => user, :object => item.to_s, :action => action, :application => application.key, :model => mdl.to_s)
+  end
+  
+end

data/app/helpers/my_admin_model_helper.rb

@@ -0,0 +1,34 @@
+module MyAdminModelHelper
+  
+  def collection_model_link(application, model, action, options={})
+    send("#{action}_#{admin_prefix}_#{application.url}_#{model.my_admin.url}_path", options )
+  end
+  
+  def member_model_link(application, model, action, options={})
+    send("#{action}_#{admin_prefix}_#{application.url}_#{model.my_admin.url_single}_path", options )
+  end
+  
+  def model_link(application, model, options={})
+    send("#{admin_prefix}_#{application.url}_#{model.my_admin.url}_path", options)
+  end
+  
+  def new_model_link(application, model, options={})
+    send("new_#{admin_prefix}_#{application.url}_#{model.my_admin.url_single}_path", options )
+  end
+  
+  def edit_model_link(application, model, item)
+    send("edit_#{admin_prefix}_#{application.url}_#{model.my_admin.url_single}_path", item)
+  end
+  
+  def show_model_link(application, model, item)
+    send("#{admin_prefix}_#{application.url}_#{model.my_admin.url_single}_path", item)
+  end
+  
+  def model_template(application, model, action)
+    template = "my_admin/#{application.key}/#{model.model_tableize}/#{action}"
+    template = "my_admin/#{application.key}/models/#{action}" if !lookup_context.exists? template, [], true and !lookup_context.exists? template, [], false
+    template = "my_admin/models/#{action}" if !lookup_context.exists? template, [], true and !lookup_context.exists? template, [], false
+    template
+  end
+
+end

data/app/helpers/my_admin_session_helper.rb

@@ -0,0 +1,50 @@
+module MyAdminSessionHelper
+
+  def my_admin_sign_in(user) 
+    cookies.permanent.signed["#{Rails.application.class.parent_name.downcase}_my_admin_remember_token"] = [user.id, user.salt] 
+    cookies.delete("#{Rails.application.class.parent_name.downcase}_my_admin_locked")
+    
+    my_admin_user = user
+  end
+  
+  def my_admin_sign_out 
+    cookies.delete("#{Rails.application.class.parent_name.downcase}_my_admin_remember_token")
+    cookies.delete("#{Rails.application.class.parent_name.downcase}_my_admin_locked")
+    my_admin_user = nil
+  end
+  
+  def my_admin_signed_in?
+    !my_admin_user.nil? and !my_admin_locked?
+  end
+  
+  def my_admin_locked?
+    !my_admin_locked.nil? 
+  end
+  
+  def my_admin_lock
+    cookies.permanent.signed["#{Rails.application.class.parent_name.downcase}_my_admin_locked"] = true
+  end
+  
+  def my_admin_user=(user) 
+    @my_admin_user = user
+  end
+  
+  def my_admin_user
+    @my_admin_user ||= my_admin_user_from_remember_token 
+  end
+  
+  private
+  
+    def my_admin_user_from_remember_token 
+      MyAdmin::User.authenticate_with_salt(*my_admin_remember_token)
+    end
+    
+    def my_admin_remember_token 
+      cookies.signed["#{Rails.application.class.parent_name.downcase}_my_admin_remember_token"] || [nil, nil]
+    end
+    
+    def my_admin_locked
+      cookies.signed["#{Rails.application.class.parent_name.downcase}_my_admin_locked"] || nil
+    end
+    
+end

data/app/mailers/my_admin/recover_mailer.rb

@@ -0,0 +1,13 @@
+# coding: utf-8
+class MyAdmin::RecoverMailer < ActionMailer::Base
+
+  include MyAdminHelper
+
+  def send_recover_mail(user)
+    @user = user
+    mail(:from => MyAdmin::Configuration.get_value(:my_admin_from_email),
+         :subject => "#{MyAdmin.title} - Recuperar Senha",
+         :to => "#{@user.full_name} <#{@user.email}>")
+  end
+
+end

data/app/model/ckeditor/asset.rb

@@ -0,0 +1,4 @@
+class Ckeditor::Asset < ActiveRecord::Base
+  include Ckeditor::Orm::ActiveRecord::AssetBase
+  include Ckeditor::Backend::Paperclip
+end

data/app/model/ckeditor/attachment_file.rb

@@ -0,0 +1,13 @@
+class Ckeditor::AttachmentFile < Ckeditor::Asset
+  has_attached_file :data,
+                    :url => "/ckeditor_assets/attachments/:id/:filename",
+                    :path => ":rails_root/public/ckeditor_assets/attachments/:id/:filename"
+
+  validates_attachment_presence :data
+  validates_attachment_size :data, :less_than => 100.megabytes
+  do_not_validate_attachment_file_type :data
+
+  def url_thumb
+    @url_thumb ||= Ckeditor::Utils.filethumb(filename)
+  end
+end

data/app/model/ckeditor/picture.rb

@@ -0,0 +1,14 @@
+class Ckeditor::Picture < Ckeditor::Asset
+  has_attached_file :data,
+                    :url  => "/ckeditor_assets/pictures/:id/:style_:basename.:extension",
+                    :path => ":rails_root/public/ckeditor_assets/pictures/:id/:style_:basename.:extension",
+                    :styles => { :content => '800>', :thumb => '118x100#' }
+
+  validates_attachment_presence :data
+  validates_attachment_size :data, :less_than => 2.megabytes
+  validates_attachment_content_type :data, :content_type => /\Aimage/
+
+  def url_content
+    url(:content)
+  end
+end

data/app/model/my_admin/configuration.rb

@@ -0,0 +1,10 @@
+class MyAdmin::Configuration < ActiveRecord::Base
+  self.table_name = "my_admin_configurations"
+  
+  validates_uniqueness_of :key
+  
+  def self.get_value(key)
+    MyAdmin::Configuration.find_by_key(key).value rescue nil
+  end
+  
+end

data/app/model/my_admin/group.rb

@@ -0,0 +1,26 @@
+class MyAdmin::Group < ActiveRecord::Base
+  self.table_name = "my_admin_groups"
+  
+  has_many :user_groups, :dependent => :destroy
+  has_many :users, :through => :user_groups
+  
+  has_many :group_permissions, :dependent => :destroy
+  has_many :permissions, :through => :group_permissions
+  
+  validates_uniqueness_of :name
+  validates_presence_of :name
+  
+  
+  config_my_admin do |admin|
+    admin.list_display = [:name, :description]
+    admin.fieldsets = [{:fields => [:name, :description]},
+                       {:name => :permissions,
+                        :fields => [:permissions]}]
+    admin.fields = {:description => {:type => :clear_text}}
+  end
+  
+  def to_s
+    self.name
+  end
+  
+end

data/app/model/my_admin/group_permission.rb

@@ -0,0 +1,7 @@
+class MyAdmin::GroupPermission < ActiveRecord::Base
+  self.table_name = "my_admin_group_permissions"
+  
+  belongs_to :permission
+  belongs_to :group
+  
+end

data/app/model/my_admin/locale.rb

@@ -0,0 +1,8 @@
+class MyAdmin::Locale < ActiveRecord::Base
+  self.table_name = "my_admin_locales"
+  
+  def to_s
+    self.name
+  end
+  
+end

data/app/model/my_admin/log.rb

@@ -0,0 +1,33 @@
+class MyAdmin::Log < ActiveRecord::Base
+  self.table_name = "my_admin_logs"
+  
+  belongs_to :user
+  
+  validates_presence_of :user, :object, :action
+  
+  scope :my_admin_order_user, lambda { |params|
+    { :include => :user, :order => "my_admin_users.first_name #{params[:order]}, my_admin_users.last_name #{params[:order]}" } if params[:order].present?
+  }
+  
+  config_my_admin do |admin|
+    admin.list_display = [:user, :application_name, :model_name, :action_name, :object, :created_at]
+    admin.filters = []
+    admin.permissions = [:list]
+    admin.fields = {:application_name => {:order => false},
+                   :model_name => {:order => false},
+                   :action_name => {:order => false}}
+  end
+  
+  def action_name
+    I18n.t("my_admin.actions.#{self.action}")
+  end
+  
+  def model_name
+    self.model.constantize.title
+  end
+  
+  def application_name
+    MyAdmin::Application.find(self.application).title
+  end
+  
+end

data/app/model/my_admin/permission.rb

@@ -0,0 +1,19 @@
+class MyAdmin::Permission < ActiveRecord::Base
+  self.table_name = "my_admin_permissions"
+  
+  has_many :group_permissions, :dependent => :destroy
+  has_many :groups, :through => :group_permissions
+  
+  validates_presence_of :model, :name, :application
+  validates_uniqueness_of :name, :scope => [:model, :name, :application]
+  
+  def to_s
+    application = MyAdmin::Application.find(self.application)
+    application.title + ">" + self.model.constantize.title + " - " + I18n.t("my_admin.permissions.#{self.name}") 
+  end
+  
+  scope :by_user, lambda { |user_id|
+    { :joins => {:groups => [:users]}, :conditions => {"my_admin_users.id" => user_id} }
+  }
+  
+end

data/app/model/my_admin/user.rb

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*-
+require 'digest'
+
+class MyAdmin::User < ActiveRecord::Base
+  self.table_name = "my_admin_users"
+  
+  has_attached_file :photo,
+    :styles => { :my_admin => "200x200#", :mini => "27x27#" },
+    :path => ":rails_root/public/uploads/:class/:id/:basename_:style.:extension",
+    :url => "/uploads/:class/:id/:basename_:style.:extension",
+    :default_url => ":class/missing_:style.png"
+    #:path => ":rails_root/public/system/:attachment/:id/:style/:filename",
+    #:url => "/system/:attachment/:id/:style/:filename"
+
+    
+  
+  before_save :encrypt_password, :if => :should_validate_password?
+  
+  has_many :user_groups, :dependent => :destroy
+  has_many :groups, :through => :user_groups
+  
+  has_many :logs
+  
+  attr_accessor :old_password, :password
+  # attr_accessible :full_name, :first_name, :last_name, :username, :photo, :superuser, :email, :old_password, :password, :password_confirmation, :active, :group_ids
+  
+  validate :check_old_password, :if => :should_validate_old_password?
+  validates_uniqueness_of :username
+  validates_uniqueness_of :email
+  validates_presence_of :first_name, :username, :email
+  validates_format_of :email, :with => /([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})/i
+
+  validates :password, :presence	=> true, :confirmation => true, :length	=> { :within => 6..40 }, :if => :should_validate_password?
+  validates_attachment_content_type :photo, :content_type => ['image/jpg', 'image/jpeg', 'image/pjpeg', 'image/gif', 'image/png', 'image/x-png'], :allow_nil => true
+
+  config_my_admin do |admin|
+    admin.list_display = [:full_name, :username, :email, :superuser, :active]
+    admin.filters = [:full_name, :username, :email]
+    admin.export_display = [:full_name, :username, :email, :superuser_export, :active_export ]
+    admin.fieldsets = [{:fields => [:username, :password, :password_confirmation]},
+                       {:name => :personal_information, 
+                        :fields => [:first_name, :last_name, :email, :photo]},
+                       {:name => :permissions,
+                        :fields => [:superuser, :active]},
+                       {:name => :groups,
+                        :fields => [:groups]}]
+    admin.fields = {:email => { :type => :email},
+                    :password => {:type => :password}, 
+                    :password_confirmation => {:type => :password}}
+  end
+  scope :my_admin_order_full_name, lambda { |params|
+    { :order => "first_name #{params[:order]}, last_name #{params[:order]}" } if params[:order].present?
+  }
+  
+  scope :my_admin_filter_full_name, lambda { |params|
+    { :conditions => ["concat_ws(' ',first_name,last_name) like ?", "%#{params[:full_name]}%"] } if params[:full_name].present?
+  }
+  
+  def permissions
+    @permissions ||= MyAdmin::Permission.by_user(self.id)
+  end
+  
+  def superuser_export
+    self.superuser ? "Sim" : "Não"
+  end
+    
+  def active_export
+    self.active ? "Sim" : "Não"
+  end
+  
+  def full_name
+    if(self.last_name.blank?)
+      self.first_name
+    else
+      "#{self.first_name} #{self.last_name}"
+    end
+  end
+  alias_method :to_s, :full_name
+  
+  def full_name=(value)
+    if value.blank?
+      self.first_name = self.last_name = nil
+    else
+      a = value.split
+      self.first_name = a[0]
+      self.last_name = a[1, a.count-1].join(' ')
+    end
+  end
+  
+  def self.recover(username, email)
+    user = find_by_username(username) 
+    if(user && user.email == email)
+      user.recover_password()
+      user
+    else
+      nil
+    end
+  end
+  
+  def self.authenticate(username, submitted_password) 
+    user = find_by_username(username) 
+    user && user.has_password?(submitted_password) ? user : nil
+  end
+  
+  def self.authenticate_with_salt(id, cookie_salt) 
+    user = find_by_id(id) 
+    (user && user.salt == cookie_salt) ? user : nil
+  end
+  
+  def has_password?(submitted_password) 
+    self.encrypted_password == encrypt(submitted_password)
+  end
+  
+  def should_validate_password?
+    (not password.blank?) || new_record? || (not old_password.nil?)
+  end
+  
+  def should_validate_old_password?
+    not old_password.nil?
+  end
+  
+  def is_active?
+    self.active
+  end
+  
+  def recover_password()
+    self.update_attribute(:encrypted_recover, encrypt("#{self.encrypted_password}#{DateTime.now}"))
+  end
+  
+  private
+    
+    def encrypt_password 
+      self.salt = make_salt if new_record? 
+      self.encrypted_password = encrypt(password)
+    end
+    
+    def encrypt(string) 
+      secure_hash("#{salt}--#{string}")
+    end
+    
+    def make_salt 
+      secure_hash("#{Time.now.utc}--#{password}")
+    end
+    
+    def secure_hash(string) 
+      Digest::SHA2.hexdigest(string)
+    end
+    
+    def check_old_password
+       errors.add(:old_password, I18n.t("activerecord.errors.messages.invalid")) unless has_password?(old_password) 
+    end
+  
+end

data/app/model/my_admin/user_group.rb

@@ -0,0 +1,7 @@
+class MyAdmin::UserGroup < ActiveRecord::Base
+  self.table_name = "my_admin_user_groups"  
+  
+  belongs_to :user
+  belongs_to :group
+  
+end