fesplugas-typus 0.9.0

data/app/helpers/admin/sidebar_helper.rb

@@ -0,0 +1,259 @@
+module Admin::SidebarHelper
+
+  def actions
+
+    returning(String.new) do |html|
+
+      html << <<-HTML
+#{build_typus_list(default_actions, :header => 'actions')}
+#{build_typus_list(previous_and_next, :header => 'go_to')}
+      HTML
+
+      html << <<-HTML
+#{build_typus_list(export, :header => 'export')}
+      HTML
+
+      %w( parent_module submodules ).each do |block|
+        html << <<-HTML
+#{build_typus_list(modules(block), :header => block)}
+        HTML
+      end
+
+    end
+
+  end
+
+  def default_actions
+
+    items = []
+
+    case params[:action]
+    when 'index', 'edit', 'show', 'update'
+      if @current_user.can_perform?(@resource[:class], 'create')
+        items << (link_to _('Add entry'), :action => 'new')
+      end
+    end
+
+    case params[:action]
+    when 'show'
+      if @current_user.can_perform?(@resource[:class], 'update')
+        items << (link_to _('Edit entry'), :action => 'edit', :id => @item.id)
+      end
+    end
+
+    @resource[:class].typus_actions_for(params[:action]).each do |action|
+      if @current_user.can_perform?(@resource[:class], action)
+        items << (link_to action.humanize, params.merge(:action => action))
+      end
+    end
+
+    case params[:action]
+    when 'new', 'create', 'edit', 'show', 'update'
+      items << (link_to _('Back to list'), :action => 'index')
+    end
+
+    return items
+
+  end
+
+  def export
+    return [] unless params[:action] == 'index'
+    returning(Array.new) do |format|
+      @resource[:class].typus_export_formats.each do |f|
+        format << (link_to f.upcase, params.merge(:format => f))
+      end
+    end
+  end
+
+  def build_typus_list(items, *args)
+
+    options = args.extract_options!
+
+    header = if options[:header]
+               _(options[:header].humanize)
+             elsif options[:attribute]
+               @resource[:class].human_attribute_name(options[:attribute])
+             end
+
+    return String.new if items.empty?
+    returning(String.new) do |html|
+      html << "<h2>#{header}</h2>\n" unless header.nil?
+      next unless options[:selector].nil?
+      html << "<ul>\n"
+      items.each do |item|
+        html << "<li>#{item}</li>\n"
+      end
+      html << "</ul>\n"
+    end
+
+  end
+
+  def modules(name)
+
+    models = case name
+             when 'parent_module': Typus.parent(@resource[:class], 'module')
+             when 'submodules':    Typus.module(@resource[:class])
+             end
+
+    return [] if models.empty?
+
+    returning(Array.new) do |items|
+      models.each do |model|
+        items << (link_to model.humanize, :controller => model.tableize)
+      end
+    end
+
+  end
+
+  def previous_and_next
+    return [] unless %w( edit show update ).include?(params[:action])
+    returning(Array.new) do |items|
+      items << (link_to _('Next'), params.merge(:id => @next.id)) if @next
+      items << (link_to _('Previous'), params.merge(:id => @previous.id)) if @previous
+    end
+  end
+
+  def search
+
+    typus_search = @resource[:class].typus_defaults_for(:search)
+    return if typus_search.empty?
+
+    search_by = typus_search.collect { |x| @resource[:class].human_attribute_name(x) }.to_sentence
+
+    search_params = params.dup
+    %w( action controller search page ).each { |p| search_params.delete(p) }
+
+    hidden_params = search_params.map { |key, value| hidden_field_tag(key, value) }
+
+    <<-HTML
+<h2>#{_('Search')}</h2>
+<form action="" method="get">
+<p><input id="search" name="search" type="text" value="#{params[:search]}"/></p>
+#{hidden_params.sort.join("\n")}
+</form>
+<p class="tip">#{_('Search by')} #{search_by.downcase}.</p>
+    HTML
+
+  end
+
+  def filters
+
+    typus_filters = @resource[:class].typus_filters
+    return if typus_filters.empty?
+
+    current_request = request.env['QUERY_STRING'] || []
+
+    returning(String.new) do |html|
+      typus_filters.each do |key, value|
+        case value
+        when :boolean:      html << boolean_filter(current_request, key)
+        when :string:       html << string_filter(current_request, key)
+        when :datetime:     html << datetime_filter(current_request, key)
+        when :belongs_to:   html << relationship_filter(current_request, key)
+        when :has_and_belongs_to_many:
+          html << relationship_filter(current_request, key, true)
+        else
+          html << "<p>#{_('Unknown')}</p>"
+        end
+      end
+    end
+
+  end
+
+  def relationship_filter(request, filter, habtm = false)
+
+    model = (habtm) ? filter.classify.constantize : filter.capitalize.camelize.constantize
+    related_fk = (habtm) ? filter : @resource[:class].reflect_on_association(filter.to_sym).primary_key_name
+
+    params_without_filter = params.dup
+    %w( controller action page ).each { |p| params_without_filter.delete(p) }
+    params_without_filter.delete(related_fk)
+
+    items = []
+
+    returning(String.new) do |html|
+      related_items = model.find(:all, :order => model.typus_order_by)
+      if related_items.size > model.typus_options_for(:sidebar_selector)
+        related_items.each do |item|
+          switch = request.include?("#{related_fk}=#{item.id}") ? 'selected' : ''
+          items << <<-HTML
+<option #{switch} value="#{url_for params.merge(related_fk => item.id, :page => nil)}">#{item.typus_name}</option>
+          HTML
+        end
+        model_pluralized = model.name.downcase.pluralize
+        form = <<-HTML
+<!-- Embedded JS -->
+<script>
+function surfto_#{model_pluralized}(form) {
+  var myindex = form.#{model_pluralized}.selectedIndex
+  if (form.#{model_pluralized}.options[myindex].value != "0") {
+    top.location.href = form.#{model_pluralized}.options[myindex].value;
+  }
+}
+</script>
+<!-- /Embedded JS -->
+<p><form class="form" action="#">
+  <select name="#{model_pluralized}" onChange="surfto_#{model_pluralized}(this.form)">
+    <option value="#{url_for params_without_filter}">#{_('filter by')} #{_(model.human_name)}</option>
+    #{items.join("\n")}
+  </select>
+</form></p>
+        HTML
+      else
+        related_items.each do |item|
+          switch = request.include?("#{related_fk}=#{item.id}") ? 'on' : 'off'
+          items << (link_to item.typus_name, params.merge(related_fk => item.id, :page => nil), :class => switch)
+        end
+      end
+
+      if form
+        html << build_typus_list(items, :attribute => filter, :selector => true)
+        html << form
+      else
+        html << build_typus_list(items, :attribute => filter)
+      end
+
+    end
+
+  end
+
+  ##
+  # Thinking in update datetime_filters to ...
+  #
+  #     %w( today last_few_days last_7_days last_30_days )
+  #
+  # ... which are the ones used by 'exception_logger'.
+  #
+  def datetime_filter(request, filter)
+    items = []
+    %w( today past_7_days this_month this_year ).each do |timeline|
+      switch = request.include?("#{filter}=#{timeline}") ? 'on' : 'off'
+      options = { filter.to_sym => timeline, :page => nil }
+      items << (link_to _(timeline.humanize), params.merge(options), :class => switch)
+    end
+    build_typus_list(items, :attribute => filter)
+  end
+
+  def boolean_filter(request, filter)
+    items = []
+    @resource[:class].typus_boolean(filter).each do |key, value|
+      switch = request.include?("#{filter}=#{key}") ? 'on' : 'off'
+      options = { filter.to_sym => key, :page => nil }
+      items << (link_to _(value), params.merge(options), :class => switch)
+    end
+    build_typus_list(items, :attribute => filter)
+  end
+
+  def string_filter(request, filter)
+    values = @resource[:class].send(filter)
+    items = []
+    values.each do |item|
+      link_name, link_filter = (values.first.kind_of?(Array)) ? [ item.first, item.last ] : [ item, item ]
+      switch = request.include?("#{filter}=#{link_filter}") ? 'on' : 'off'
+      options = { filter.to_sym => link_filter, :page => nil }
+      items << (link_to link_name.capitalize, params.merge(options), :class => switch)
+    end
+    build_typus_list(items, :attribute => filter)
+  end
+
+end

data/app/helpers/admin/table_helper.rb

@@ -0,0 +1,227 @@
+module Admin::TableHelper
+
+  def build_typus_table(model, fields, items, link_options = {}, association = nil)
+
+    returning(String.new) do |html|
+
+      html << <<-HTML
+<table>
+      HTML
+
+      html << typus_table_header(model, fields)
+
+      items.each do |item|
+
+        html << <<-HTML
+<tr class="#{cycle('even', 'odd')}" id="item_#{item.id}">
+        HTML
+
+        fields.each do |key, value|
+          case value
+          when :boolean:           html << typus_table_boolean_field(key, item)
+          when :datetime:          html << typus_table_datetime_field(key, item, fields.keys.first, link_options)
+          when :date:              html << typus_table_datetime_field(key, item, fields.keys.first, link_options)
+          when :time:              html << typus_table_datetime_field(key, item, fields.keys.first, link_options)
+          when :belongs_to:        html << typus_table_belongs_to_field(key, item)
+          when :tree:              html << typus_table_tree_field(key, item)
+          when :position:          html << typus_table_position_field(key, item)
+          when :has_and_belongs_to_many:
+            html << typus_table_has_and_belongs_to_many_field(key, item)
+          else
+            html << typus_table_string_field(key, item, fields.keys.first, link_options)
+          end
+        end
+
+      ##
+      # This controls the action to perform. If we are on a model list we 
+      # will remove the entry, but if we inside a model we will remove the 
+      # relationship between the models.
+      #
+      # Only shown is the user can destroy items.
+      #
+
+      if @current_user.can_perform?(model, 'delete')
+
+        case params[:action]
+        when 'index'
+          perform = link_to image_tag('admin/trash.gif'), { :action => 'destroy', 
+                                                            :id => item.id }, 
+                                                            :confirm => _('Remove entry?'), 
+                                                            :method => :delete
+        else
+          perform = link_to image_tag('admin/trash.gif'), { :action => 'unrelate', 
+                                                            :id => params[:id], 
+                                                            :association => association, 
+                                                            :resource => model, 
+                                                            :resource_id => item.id }, 
+                                                            :confirm => _("Unrelate {{unrelate_model}} from {{unrelate_model_from}}?", 
+                                                                          :unrelate_model => model.human_name, 
+                                                                          :unrelate_model_from => @resource[:class].human_name)
+        end
+
+        html << <<-HTML
+<td width="10px">#{perform}</td>
+        HTML
+
+      end
+
+      html << <<-HTML
+</tr>
+      HTML
+
+    end
+
+      html << "</table>"
+
+    end
+
+  end
+
+  ##
+  # Header of the table
+  #
+  def typus_table_header(model, fields)
+    returning(String.new) do |html|
+      headers = []
+      fields.each do |key, value|
+
+        content = model.human_attribute_name(key)
+        content += " (#{key})" if key.include?('_id')
+
+        if (model.model_fields.map(&:first).collect { |i| i.to_s }.include?(key) || model.reflect_on_all_associations(:belongs_to).map(&:name).include?(key.to_sym)) && params[:action] == 'index'
+          sort_order = case params[:sort_order]
+                       when 'asc':  'desc'
+                       when 'desc': 'asc'
+                       end
+          order_by = model.reflect_on_association(key.to_sym).primary_key_name rescue key
+          switch = (params[:order_by] == key) ? sort_order : ''
+          options = { :order_by => order_by, :sort_order => sort_order }
+          content = (link_to "<div class=\"#{switch}\">#{content}</div>", params.merge(options))
+        end
+
+        headers << "<th>#{content}</th>"
+
+      end
+      headers << "<th>&nbsp;</th>" if @current_user.can_perform?(model, 'delete')
+      html << <<-HTML
+<tr>
+#{headers.join("\n")}
+</tr>
+      HTML
+    end
+  end
+
+  def typus_table_belongs_to_field(attribute, item)
+
+    action = item.send(attribute).class.typus_options_for(:default_action_on_item) rescue 'edit'
+
+    content = if !item.send(attribute).kind_of?(NilClass)
+                link_to item.send(attribute).typus_name, :controller => "admin/#{attribute.pluralize}", :action => action, :id => item.send(attribute).id
+              end
+
+    <<-HTML
+<td>#{content}</td>
+    HTML
+
+  end
+
+  def typus_table_has_and_belongs_to_many_field(attribute, item)
+    <<-HTML
+<td>#{item.send(attribute).map { |i| i.typus_name }.join('<br />')}</td>
+    HTML
+  end
+
+  ##
+  # When detection of the attributes is made a default attribute 
+  # type is set. From the string_field we display other content 
+  # types.
+  #
+  def typus_table_string_field(attribute, item, first_field, link_options = {})
+
+    action = item.class.typus_options_for(:default_action_on_item)
+
+    content = if first_field == attribute
+                link_to item.send(attribute) || item.class.typus_options_for(:nil), link_options.merge(:controller => "admin/#{item.class.name.tableize}", :action => action, :id => item.id)
+              else
+                item.send(attribute)
+              end
+    <<-HTML
+<td>#{content}</td>
+    HTML
+  end
+
+  def typus_table_tree_field(attribute, item)
+    <<-HTML
+<td>#{item.parent.typus_name if item.parent}</td>
+    HTML
+  end
+
+  def typus_table_position_field(attribute, item)
+
+    html_position = []
+
+    [['Up', 'move_higher'], ['Down', 'move_lower']].each do |position|
+
+      options = { :controller => item.class.name.tableize, 
+                  :action => 'position', 
+                  :id => item.id, 
+                  :go => position.last }
+
+      html_position << <<-HTML
+#{link_to _(position.first), params.merge(options)}
+      HTML
+
+    end
+
+    <<-HTML
+<td>#{html_position.join('/ ')}</td>
+    HTML
+
+  end
+
+  def typus_table_datetime_field(attribute, item, first_field = nil, link_options = {} )
+
+    action = item.class.typus_options_for(:default_action_on_item)
+
+    date_format = item.class.typus_date_format(attribute)
+    value = !item.send(attribute).nil? ? item.send(attribute).to_s(date_format) : item.class.typus_options_for(:nil)
+    content = if first_field == attribute
+                link_to value, link_options.merge(:controller => "admin/#{item.class.name.tableize}", :action => action, :id => item.id )
+              else
+                value
+              end
+
+    <<-HTML
+<td>#{content}</td>
+    HTML
+
+  end
+
+  def typus_table_boolean_field(attribute, item)
+
+    boolean_icon = item.class.typus_options_for(:icon_on_boolean)
+    boolean_hash = item.class.typus_boolean(attribute)
+
+    status = item.send(attribute)
+
+    link_text = unless item.send(attribute).nil?
+                  (boolean_icon) ? image_tag("admin/status_#{status}.gif") : boolean_hash["#{status}".to_sym]
+                else
+                  item.class.typus_options_for(:nil) # Content is nil, so we show nil.
+                end
+
+    options = { :controller => item.class.name.tableize, :action => 'toggle', :field => attribute, :id => item.id }
+
+    content = if item.class.typus_options_for(:toggle) && !item.send(attribute).nil?
+                link_to link_text, params.merge(options), :confirm => _("Change {{attribute}}?", :attribute => item.class.human_attribute_name(attribute).downcase)
+              else
+                link_text
+              end
+
+    <<-HTML
+<td align="center">#{content}</td>
+    HTML
+
+  end
+
+end

data/app/helpers/typus_helper.rb

@@ -0,0 +1,169 @@
+module TypusHelper
+
+  ##
+  # Applications list on the dashboard
+  #
+  def applications
+
+    returning(String.new) do |html|
+
+      Typus.applications.each do |app|
+
+        available = Typus.application(app).map do |resource|
+                      resource if @current_user.resources.include?(resource)
+                    end
+        next if available.compact.empty?
+
+        html << <<-HTML
+<table>
+<tr>
+<th colspan="2">#{app}</th>
+</tr>
+        HTML
+
+        available.compact.each do |model|
+          description = Typus.module_description(model)
+          admin_items_path = { :controller => "admin/#{model.tableize}" }
+          new_admin_item_path = { :controller => "admin/#{model.tableize}", :action => 'new'}
+          html << <<-HTML
+<tr class="#{cycle('even', 'odd')}">
+<td>#{link_to _(model.constantize.human_name.pluralize), admin_items_path}<br /><small>#{description}</small></td>
+<td class="right"><small>
+#{link_to _('Add'), new_admin_item_path if @current_user.can_perform?(model, 'create')}
+</small></td>
+</tr>
+          HTML
+        end
+
+        html << <<-HTML
+</table>
+        HTML
+
+      end
+
+    end
+
+  end
+
+  ##
+  # Resources (wich are not models) on the dashboard.
+  #
+  def resources
+
+    available = Typus.resources.map do |resource|
+                  resource if @current_user.resources.include?(resource)
+                end
+    return if available.compact.empty?
+
+    returning(String.new) do |html|
+
+      html << <<-HTML
+<table>
+<tr>
+<th colspan="2">#{_("Resources")}</th>
+</tr>
+      HTML
+
+      available.compact.each do |resource|
+
+        resource_path = { :controller => "admin/#{resource.underscore}" }
+
+        html << <<-HTML
+<tr class="#{cycle('even', 'odd')}">
+<td>#{link_to _(resource.humanize), resource_path}</td>
+<td align="right" style="vertical-align: bottom;"></td>
+</tr>
+        HTML
+
+      end
+
+      html << <<-HTML
+</table>
+      HTML
+
+    end
+
+  end
+
+  def typus_block(*args)
+
+    options = args.extract_options!
+    template = [ 'admin', options[:resource], options[:location], "_#{options[:partial]}.html.erb" ].compact.join('/')
+
+    exists = ActionController::Base.view_paths.map { |vp| File.exists?("#{vp}/#{template}") }
+
+    return unless exists.include?(true)
+    render :partial => template.gsub('/_', '/')
+
+  end
+
+  def page_title(action = params[:action])
+    crumbs = [ Typus::Configuration.options[:app_name] ]
+    crumbs << @resource[:class].human_name.pluralize if @resource
+    crumbs << _(action.humanize) unless %w( index ).include?(action)
+    return crumbs.compact.map { |x| x }.join(' &rsaquo; ')
+  end
+
+  def header
+
+    if ActionController::Routing::Routes.named_routes.routes.keys.include?(:root)
+      link_to_site = <<-HTML
+<small>#{link_to _('View site'), root_path, :target => 'blank'}</small>
+      HTML
+    end
+
+    <<-HTML
+<h1>#{Typus::Configuration.options[:app_name]} #{link_to_site}</h1>
+    HTML
+
+  end
+
+  def login_info(user = @current_user)
+
+    admin_edit_typus_user_path = { :controller => "admin/#{Typus::Configuration.options[:user_class_name].tableize}", 
+                                   :action => 'edit', 
+                                   :id => user.id }
+
+    <<-HTML
+<ul>
+  <li>#{_('Logged as')} #{link_to user.full_name(:display_role => true), admin_edit_typus_user_path}</li>
+  <li>#{link_to _('Sign out'), admin_sign_out_path }</li>
+</ul>
+    HTML
+
+  end
+
+  def display_flash_message(message = flash)
+
+    return if message.empty?
+    flash_type = message.keys.first
+
+    <<-HTML
+<div id="flash" class="#{flash_type}">
+  <p>#{message[flash_type]}</p>
+</div>
+    HTML
+
+  end
+
+  def typus_message(message, html_class = 'notice')
+    <<-HTML
+<div id="flash" class="#{html_class}">
+  <p>#{message}</p>
+</div>
+    HTML
+  end
+
+  def locales(uri = admin_set_locale_path)
+
+    return unless Typus.locales.many?
+
+    locale_links = Typus.locales.map { |l| "<a href=\"#{uri}?locale=#{l.last}\">#{l.first.downcase}</a>" }
+
+    <<-HTML
+<p>#{_('Set language to')} #{locale_links.join(', ')}.</p>
+    HTML
+
+  end
+
+end

data/app/models/typus_mailer.rb

@@ -0,0 +1,14 @@
+class TypusMailer < ActionMailer::Base
+
+  self.template_root = "#{File.dirname(__FILE__)}/../views"
+
+  def reset_password_link(user)
+    @subject    = "[#{Typus::Configuration.options[:app_name]}] #{_('Reset password')}"
+    @body       = { :user => user }
+    @recipients = user.email
+    @from       = Typus::Configuration.options[:email]
+    @sent_on    = Time.now
+    @headers    = {}
+  end
+
+end

data/app/models/typus_user.rb

@@ -0,0 +1,5 @@
+class TypusUser < ActiveRecord::Base
+
+  enable_as_typus_user
+
+end

data/app/views/admin/dashboard/_sidebar.html.erb

@@ -0,0 +1,9 @@
+<h2>Welcome to Typus!</h2>
+
+<p>Documentation is available <a href="http://intraducibles.com/projects/typus">here</a>.</p>
+
+<p>If you need help don't hesitate in joining the <a href="http://groups.google.com/group/typus" rel="external">Typus</a> mailing list.</p>
+
+<p>Replace this message adding a <code>_sidebar.html.erb</code> file on the <code>app/views/admin/dashboard</code> folder.</p>
+
+<p>Have a nice day!</p>