dashboard-rails 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a86427f3df1221fe3e57a76b2018089abc3264a47ab1f8ca71619cf547ae7cd
+  data.tar.gz: 56714713af95f13099f3721281b037a59c42a4e68dd2b55ae3c28adbc04a80d8
+SHA512:
+  metadata.gz: 5c5c522b76dfa3d830dec7da01b35a7f67cd3331596fe34460a59c5f981fba735a5f077a9bf345cfef977f0058791ef21a2a8ac85b50f6edb5653060709797f2
+  data.tar.gz: 3129075c90183adc2ed987134bd164d87c2fb049878bfea9b7b9eef79d5074b32cd98a4cf76fd161e86e01a54bd1185e89016c47791cf273135df19b8cc6d613

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Daniel de Carvalho Passarini
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,198 @@
+# Dashboard Rails
+
+This Gem was designed to help create a dashboard page where the user can configure the diplayed widgets.
+
+The user selects the widgets that he would like to display and save this information to the database so next time he
+loads the application the desired widgets will be displayed.
+
+For the moment we require a model *User* and the method *current_user* 
+
+## TODO
+
+- Configure page layout (number and size of columns)
+- Define widgets position in the page using drag & drop
+- Define the auto refrsesh interval (today fixed in 60 seconds)
+
+### Installation
+
+Add the gem to the Gemfile
+
+```ruby
+gem 'dashboard-rails'
+```
+run bundle install
+
+```sh
+$ bundle install
+```
+
+Generate some required files using the provided install generator
+```sh
+$ rails g dashboard-rails:install
+```
+
+A migration will be created the table to keep the dashboard settings per user
+
+```sh
+$ rake db:migrate
+```
+
+Add the provide css to  **application.css**
+```js
+    *= require dashboard-rails
+```
+
+Add the provide js to **application.js**
+```js
+    //= require dashboard-rails
+```
+
+### Dashboard Page
+
+Create you dashboard page, just add the following helper to your page
+
+```html
+<%= dashboard_view %>
+```
+
+Or, you can generate the dashboard viwes in your project to customize it
+
+```sh
+rails g dashboard-rails:view
+```
+
+### the Dashboard Configuration Page
+
+Create you confi dashboard page, just add the following helper to your page
+
+```html
+<%= config_dashboard_view %>
+```
+
+
+<%= config_dashboard_path %>
+
+
+Or, you can generate the dashboard viwes in your project to customize it
+
+```sh
+rails g dashboard-rails:view
+```
+
+
+### Widget Generators
+
+To create the widget skeleton use:
+```sh
+rails generate dashboard-rails:widget #{widget_name}
+```
+
+
+All widgets are create under the `app/widgets` folder
+
+
+## How to create a Widget
+
+For example:
+
+```ruby
+class ExemploWidget < ApplicationWidget
+
+  name! 'Widget Exemplo'
+  description! 'Esse Widget é apenas um exemplo'
+
+  description! :executar, 'Essa ação é um outro exemplo'
+  def executar
+    @ano =  params[:ano] || Date.today.year
+  end
+
+end
+```
+
+**Cada ação será uma visão diferente do widget. Exemplo: Calendário Mensal, Calendário Semanal, você terá o widget Calendários e as ações mensal e semanal.**
+
+Parametros utilizados como documentação para exibir na lista de configuração de Widgets x Usuários.
+
+- **name!** identifica o nome (título) do Widget. 
+- **description!** é a descrição (função)  do Widget.
+- **description! :acao** é a descrição (função) da ação daquele Widget.
+
+O conteúdo visual do Widget (VIEW) seguirá o padrão do rails estando na pasta `app/views/widgets/nome_do_widget/nome_da_acao.html.erb`:
+
+*app/widgets/exemplo/executar.html.erb*
+```html
+<div>
+Meu widget de exemplo retornou o ano: <%= @ano %>
+<%= link_to 'Próximo Ano e recarregar Widget', widget_path(ano: (@ano +1), widget_ajax: true %>
+<%= link_to 'Ir para página externa normalmente', 'http://www.google.com.br/' %>
+</div>
+```
+
+Para direcionar o usuário para configurar seus widgets, faça um link para `dashboard-rails_path`
+```html
+<%= link_to 'Gerenciar Widgets', dashboard-rails_path %>
+
+<%= link_to 'Gerenciar Widgets', dashboard_settings_path %>
+
+
+```
+
+### Helpers
+
+Para verificar a permissão de acesso ao Widget pelo usuário atual (current_user), utilize o helper `user_can_widget?(nome_widget, ação)`:
+```html
+<% if show_widget?(:calendarios, :mensal) %>
+ 
+<% end %>
+```
+
+Para adicionar um widget use o helper `add_widget(nome_widget, ação)`:
+```html
+<%= add_widget(:calendarios, :mensal) %>
+```
+
+Para referenciar um path do widget de forma automática utilize `widget_path`. Esse helper espera que haja definido em params *widget_name* e *widget_name* :
+```html
+<!-- ESPERA QUE EXISTA params[:widget_name] e params[:widget_action] definidos -->
+<%= widget_path(novo_atributo: 'novo valor') %>
+``` 
+
+Para criar um link que faça uma chamada ajax e retorne o resultado HTML no próprio widget (como mudar de página por exemplo):
+```html
+<%= link_to 'Link Remoto', widget_path({ano: @ano}), widget_ajax: true %>
+```
+
+Formulário para reescrever o plugin baseado em algum parametro:
+```html
+<%= form_tag widget_path, method: :get, widget_ajax: true do %>
+
+<% end %>
+```
+
+### Atualização Manual do Widget
+
+Para atualizar um widget de forma manual você precisa recuperar o elemento do widget com a classe `widget` e chamar o método `widget_load_from_ajax`:
+```javascript
+var elemento = $('.widget:first')
+//Esse elemento precisa ser um elemento jQuery
+widget_load_from_ajax(elemento);
+```
+
+### Recursos AJAX (automáticos)
+
+Toda vez que um elemento com classe `widget-user-control` for alterado será disparado um evento AJAX que irá localizar as configuraçẽos do usuário na view de configuração e retornará um HTML com o conteúdo no elemento `.widgets_list .list`. Caso não seja informado esse item, o primeiro formulário com a classe `widget_config` será passado como elemento destino.
+
+Todo formulário em widget que tenha a atributo `widget_ajax` terá seu evento "submit" enviado por AJAX, retornando o resultado no próprio container do widget, portanto é esperado um retorno HTML.
+ 
+Todo elemento com atributo `data-url` tentará criar um contador com tempo igual ao atributo `data-tick` para atualização automática do widget.
+
+
+
+# Developers
+
+To publish this gem use:
+
+```sh
+gem push dashboard-rails-0.1.0.gem
+
+```

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+# require 'rdoc/task'
+# RDoc::Task.new(:rdoc) do |rdoc|
+#   rdoc.rdoc_dir = 'rdoc'
+#   rdoc.title    = 'DashboardRails'
+#   rdoc.options << '--line-numbers'
+#   rdoc.rdoc_files.include('README.rdoc')
+#   rdoc.rdoc_files.include('lib/**/*.rb')
+# end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks
+
+# require 'rake/testtask'
+#
+# Rake::TestTask.new(:test) do |t|
+#   t.libs << 'lib'
+#   t.libs << 'test'
+#   t.pattern = 'test/**/*_test.rb'
+#   t.verbose = false
+# end
+#
+#
+# task default: :test

data/app/assets/javascripts/dashboard-rails.js

@@ -0,0 +1,119 @@
+function hasParams(url) {
+    var regex = new RegExp(/\?\w+\=/);
+    regex.test(url);
+}
+
+function widget_load_from_ajax($el, new_url) {
+    if ($el!=undefined && $el!=null && $el instanceof jQuery) {
+        var dest_url = (new_url != undefined ? new_url : $el.attr('data-url'));
+        // var query_string = window.location.search.substring(1);
+        // if (query_string!=undefined && query_string!=null) {
+        //     dest_url = dest_url + (hasParams(dest_url) ? '&' : '?') + query_string;
+        // }
+        $.ajax({
+            url: dest_url,
+            method: 'get',
+            dataType: 'html',
+            beforeSend: function (jqXHR, settings) {
+                widget_loading($el);
+            },
+            success: function (data, textStatus, jqXHR) {
+                //console.log('sucesso');
+                $el.html(data);
+                if (new_url != undefined) {
+                    $el.attr('data-url', new_url);
+                }
+            },
+            error: function (jqXHR, textStatus, errorThrown) {
+                console.log('erro',jqXHR);
+            },
+            complete: function (jqXHR, textStatus) {
+                widget_loading($el, false);
+            }
+        });
+    } else {
+        alert('Erro! Objeto Widget Não encontrado!');
+    }
+}
+
+function widget_load_user_config(user_id, elDestBlock) {
+    var $elDestBlock = $('.widget_config');
+    var $elDestList = $elDestBlock.find('.widgets_list .list');
+    $.ajax({
+        url: '/dashboard-rails/widgets/user/'+user_id,
+        method: 'get',
+        dataType: 'html',
+        beforeSend: function (jqXHR, settings) {
+            widget_loading($elDestBlock);
+        },
+        success: function (data, textStatus, jqXHR) {
+            // console.log(data);
+            $elDestList.html(data);
+        },
+        error: function (jqXHR, textStatus, errorThrown) {
+            console.log('erro',jqXHR);
+        },
+        complete: function (jqXHR, textStatus) {
+            widget_loading($elDestBlock, false);
+        }
+    });
+}
+
+function widget_loading(element, state) {
+    var $el = $(element);
+    if (state==undefined) state=true;
+
+    if (state==true) {
+        $("<div class='widget_loading'><span>Carregando...</span></div>").appendTo($el);
+    } else {
+        $el.find('.widget_loading').fadeOut('fast', function(){
+            $(this).remove();
+        });
+    }
+}
+
+//FORMS
+$(document).on('submit','form[widget_ajax]', function(ev) {
+    ev.preventDefault();
+    var widget_element = $(this).closest('.widget'),
+        atributos = $(this).serialize(),
+        form_url = $(this).attr('action');
+    if (atributos!=undefined && atributos!=null) {
+        form_url = form_url + (hasParams(form_url) ? '&' : '?') + atributos;
+    }
+    widget_load_from_ajax(widget_element, form_url);
+});
+
+//LINKS
+$(document).on('click','a[widget_ajax]', function(ev) {
+    ev.preventDefault();
+    var widget_element  = $(this).closest('.widget');
+    var new_url = $(this).attr('href');
+    widget_load_from_ajax(widget_element, new_url);
+});
+
+//USER CONTORL
+$(document).on('change','.widget-user-control', function(ev) {
+    var $el = $(this);
+    widget_load_user_config($el.val());
+});
+
+$(document).on('ready',function(){
+
+    $('.widget[data-url]').each(function(i,el) {
+        var $el = $(el);
+        var delay_in_ms = $el.attr('data-tick') || 0;
+        widget_load_from_ajax($el);
+        if (delay_in_ms > 0) {
+            window.setInterval(function(){ widget_load_from_ajax($el); }, delay_in_ms);
+        }
+    });
+
+    //INIT
+    if ($('.widget-user-control').length > 0) {
+        $('.widget-user-control').trigger('change');
+    } else {
+        widget_load_user_config('');
+    }
+
+});

data/app/assets/stylesheets/dashboard-rails.css

@@ -0,0 +1,40 @@
+.widget {
+    position: relative;
+    min-height: 50px;
+}
+
+.widgets_list ul {
+    padding-left: 0px;
+}
+
+.widgets_list ul li {
+    list-style: none;
+}
+
+.widget_loading {
+    position: absolute;
+    width: 100%;
+    height: 100%;
+    min-height: 50px;
+    top: 0;
+    left: 0;
+    background-color: #ccc;
+    opacity: 0.5;
+    border-radius: 5px;
+    cursor: not-allowed;
+}
+
+.widget_loading span {
+    background-color: #FFF;
+    font-size: 18px;
+    color: #000;
+    padding: 5px;
+    font-weight: bold;
+    margin: 0;
+    border-radius: 5px;
+    position: absolute;
+    top: 50%;
+    left: 50%;
+    margin-right: -50%;
+    transform: translate(-50%, -50%);
+}

data/app/controllers/application_widget.rb

@@ -0,0 +1,56 @@
+class ApplicationWidget < ::ApplicationController
+  include SingletonHelper
+
+  attr_singleton :refresh_interval, 0
+
+  def initialize(request)
+    self.request = request
+  end
+
+  def render_template(view_file=nil, *args)
+    args << {template: view_file}
+    render_to_string *args
+  end
+
+  def view(view_file=nil, klass=nil)
+    class_caller = klass || (caller[0].match(/(\b\w+)\.rb/)[1] rescue '')
+    action_caller = view_file || (caller[0].match(/`(.*)'/)[1] rescue '')
+    view_file = "widgets/#{class_caller.to_s.sub('_widget','')}/#{action_caller}" unless lookup_context.find_all(view_file).any?
+    instance_variable_set(:@view_file, view_file)
+  end
+
+  def self.name?
+    instance_variable_defined?(:@widget_name) ? instance_variable_get(:@widget_name) : ''
+  end
+
+  def self.name!(value)
+    # define_singleton_method(:widget_name) {value}
+    instance_variable_set(:@widget_name, value)
+  end
+
+  def self.description?(attr=nil)
+    attr='widget' if attr.nil?
+    instance_variable_defined?("@description_#{attr}") ? instance_variable_get("@description_#{attr}") : ''
+  end
+
+  def self.description!(*args)
+    if args.size == 1
+      instance_variable_set(:@description_widget, args[0])
+    elsif args.size == 2
+      instance_variable_set("@description_#{args[0]}", args[1])
+    end
+  end
+
+  def self.widgets
+    # ApplicationWidget.descendants.map do |klass| #Não estava carregando no primeiro load...
+    Dir["#{Rails.root}/app/widgets/*.rb"].map do |file_path|
+      file_name = File.basename(file_path, ".rb")
+      klass = Object.const_get file_name.classify
+      actions = klass.instance_methods(false).map do |action|
+        {name: action, description: klass.description?(action)}
+      end
+      {code: klass.to_s.tableize.sub('_widgets',''), name: klass.name?, description: klass.description?, actions: actions}
+    end
+  end
+
+end

data/app/controllers/dashboard-rails/application_controller.rb

@@ -0,0 +1,5 @@
+module DashboardRails
+  class ApplicationController < ::ApplicationController #< ActionController::Base #ENGINE
+
+  end
+end

data/app/controllers/dashboard-rails/widgets_controller.rb

@@ -0,0 +1,46 @@
+require_dependency "dashboard-rails/application_controller"
+
+module DashboardRails
+  class WidgetsController < ApplicationController
+
+    def load
+      widget = DashboardRails::Widget.new(params[:widget_name], self.request)
+      content = widget.html(params[:widget_action])
+    rescue Exception => e
+      content = e.message
+    ensure
+      render html: content, layout: false
+    end
+
+    def user
+      user_id = params[:id]
+      @widgets_code = DashboardRails::User.where(user_id: user_id).pluck(:widget, :action).map{|r| "#{r[0]}_#{r[1]}"}
+      render partial: 'widgets_list'
+    end
+
+    def index
+      @user_id = params[:user_id] || current_user.id
+    end
+
+    def save
+      user_id = params[:user_id]
+      widgets = params[:widgets]
+      widget_name_user = []
+      action_user = []
+      if user_id.present? && widgets.present?
+        widgets.each do |widget|
+          widget_name, action = widget.split('|')
+          if widget_name && action
+            widget_name_user << widget_name
+            action_user << action
+            DashboardRails::User.find_or_create_by(widget: widget_name, action: action, user_id: user_id)
+          end
+        end
+      end
+      DashboardRails::User.where(user_id: user_id).where.not(widget: widget_name_user, action: action_user).destroy_all
+      flash[:success] = 'Alterações foram salvas com sucesso!'
+      redirect_to dashboard-rails_path(user_id: user_id)
+    end
+
+  end
+end

data/app/helpers/dashboard-rails/application_helper.rb

@@ -0,0 +1,20 @@
+module DashboardRails
+  module ApplicationHelper
+
+    def add_widget(widget_name, widget_action)
+      widget = DashboardRails::Widget.new(widget_name, self.request)
+      content_tag(:div, '', id: "widget_#{widget_name}_#{widget_action}", class: 'widget', data: {tick: widget.param(:refresh_interval), url: dashboard-rails_load_path(widget_name: widget_name, widget_action: widget_action)})
+    end
+
+    def widget_path(args=nil)
+      my_params = {widget_name: params[:widget_name], widget_action: params[:widget_action]}
+      my_params.merge!(args) if args.present?
+      dashboard-rails_load_path(my_params)
+    end
+
+    def user_can_widget?(widget_name, widget_action)
+      DashboardRails::User.where(user_id: current_user.id, widget: widget_name, action: widget_action).count > 0
+    end
+
+  end
+end

data/app/models/dashboard-rails/user.rb

@@ -0,0 +1,9 @@
+module DashboardRails
+  class User < ActiveRecord::Base
+
+    self.table_name = :dashboard_settings
+    belongs_to :user
+    validates :widget, :action, presence: true
+
+  end
+end

data/app/views/dashboard-rails/widgets/_widgets_list.html.erb

@@ -0,0 +1,24 @@
+<% ApplicationWidget.widgets.each do |widget| %>
+    <ul>
+      <li>
+        <b><%= widget[:name] %></b>
+        <br><span class="help-block"><%= widget[:description] %></span>
+        <ul>
+          <% widget[:actions].each do |action| %>
+              <% widget_code = "#{widget[:code]}_#{action[:name]}" %>
+              <li>
+                <div class="checkbox">
+                  <%= label_tag widget_code do %>
+                      <%= check_box_tag 'widgets[]', "#{widget[:code]}|#{action[:name]}", @widgets_code.include?(widget_code), {id: widget_code} %>
+                      <b><%= action[:name].to_s.humanize %></b>
+                      <% if action[:description].present? %>
+                          <br><span class="help-block"><%= action[:description] %></span>
+                      <% end %>
+                  <% end %>
+                </div>
+              </li>
+          <% end %>
+        </ul>
+      </li>
+    </ul>
+<% end %>

data/app/views/dashboard-rails/widgets/index.html.erb

@@ -0,0 +1,25 @@
+<div class="row">
+  <div class="col-md-12">
+    <div class="panel panel-default">
+      <div class="panel-heading">
+        <div class="panel-title">Selecione os Widgets que deseja utilizar:</div>
+      </div>
+      <div class="panel-body">
+        <%= form_tag(dashboard-rails_save_path, method: :put, class: 'widget_config') do %>
+
+          <div class="form-group">
+            <label class="control-label">Usuário:</label>
+            <%= select_tag :user_id, options_from_collection_for_select(User.all, :id, :email, current_user.id), include_blank: false, class: 'form-control widget-user-control' %>
+          </div>
+
+          <fieldset class="widgets_list">
+            <legend>Widgets</legend>
+            <div class="list"></div>
+          </fieldset>
+
+          <%= submit_tag "Salvar", class: 'btn btn-success' %>
+        <% end %>
+      </div>
+    </div>
+  </div>
+</div>

data/config/initializers/assets.rb

@@ -0,0 +1 @@
+Rails.application.config.assets.precompile += %w( dashboard-rails.js dashboard-rails.css  )

data/config/routes.rb

@@ -0,0 +1,19 @@
+Rails.application.routes.draw do
+
+
+  namespace :dashboard-rails do
+
+    get 'widgets/load/:widget_name/:widget_action', to: 'widgets#load', as: 'load'
+    get 'widgets/user(/:id)', to: 'widgets#user', as: 'user'
+    get 'widgets', to: 'widgets#index', as: ''
+    put 'widgets/save', to: 'widgets#save', as: 'save'
+
+
+  end
+
+
+
+
+
+
+end

data/lib/dashboard-rails.rb

@@ -0,0 +1,8 @@
+# require 'haml'
+require 'dashboard-rails/engine'
+require 'dashboard-rails/singleton_helper'
+require 'dashboard-rails/widget'
+
+module DashboardRails
+  # Mime::Type.register "application/vnd.ms-excel", :xls
+end

data/lib/dashboard-rails/engine.rb

@@ -0,0 +1,6 @@
+module DashboardRails
+  class Engine < ::Rails::Engine
+    # config.eager_load_paths << DashboardRails::Engine.root.join('app','widgets')
+    config.autoload_paths << DashboardRails::Engine.root.join('app','widgets')
+  end
+end

data/lib/dashboard-rails/singleton_helper.rb

@@ -0,0 +1,19 @@
+module SingletonHelper
+
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def attr_singleton(attr, default=nil)
+      define_singleton_method attr do |value=nil|
+        if value.present?
+          instance_variable_set("@#{attr}", value)
+        else
+          instance_variable_get("@#{attr}") || default
+        end
+      end
+    end
+  end
+
+end

data/lib/dashboard-rails/version.rb

@@ -0,0 +1,3 @@
+module DashboardRails
+  VERSION = '1.0.0'
+end

data/lib/dashboard-rails/widget.rb

@@ -0,0 +1,23 @@
+module DashboardRails
+  class Widget
+
+    attr_accessor :widget, :klass
+
+    def initialize(widget_name, request)
+      @klass_name = widget_name
+      @klass = Object.const_get "#{@klass_name}_widget".classify
+      @widget = @klass.new(request)
+    end
+
+    def param(param)
+      @klass.send(param)
+    end
+
+    def html(action)
+      content = @widget.send(action)
+      view_file = (@widget.instance_variables.include?(:@view_file) ? @widget.instance_variable_get(:@view_file) : @widget.view(action, @klass_name))
+      @widget.render_template(view_file) # rescue content
+    end
+
+  end
+end

data/lib/generators/dashboard-rails/install_generator.rb

@@ -0,0 +1,26 @@
+require 'rails/generators/base'
+require 'rails/generators/migration'
+
+module DashboardRails
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../../templates", __FILE__)
+    include Rails::Generators::Migration
+
+    class_option :orm
+    desc 'Instalando Taxweb Widgets'
+
+    desc 'Criando Migrations'
+    def self.next_migration_number(path)
+      unless @prev_migration_nr
+        @prev_migration_nr = Time.now.utc.strftime("%Y%m%d%H%M%S").to_i
+      else
+        @prev_migration_nr += 1
+      end
+      @prev_migration_nr.to_s
+    end
+
+    def create_migration_file
+      migration_template 'create_dashboard-rails_users.rb', 'db/migrate/create_dashboard-rails_users.rb'
+    end
+  end
+end

data/lib/generators/dashboard-rails/view_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators/base'
+
+module DashboardRails
+  class ViewGenerator < Rails::Generators::Base
+    source_root File.expand_path("../../../../app/views/dashboard-rails", __FILE__)
+
+    def copy_views
+      directory 'widgets', 'app/views/dashboard-rails/widgets'
+    end
+  end
+end

data/lib/generators/dashboard-rails/widget_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/base'
+
+module DashboardRails
+  class WidgetGenerator < Rails::Generators::NamedBase
+    source_root File.expand_path("../../templates", __FILE__)
+
+    def generate_widget
+      @widget_name = file_name.classify
+      view_dir = "app/views/widgets/#{widget_name_file}"
+
+      template "generic_widget.erb", File.join('app/widgets', "#{widget_name_file}_widget.rb")
+
+      if self.behavior == :revoke && Dir.exists?(view_dir)
+        require 'fileutils'
+        FileUtils.rm_rf(view_dir)
+      elsif self.behavior == :invoke
+        copy_file "generic_widget.html.erb", File.join(view_dir, 'exemplo.html.erb')
+      end
+    end
+
+    def widget_name_file
+      file_name.underscore
+    end
+  end
+end

data/lib/generators/templates/create_taxweb_widgets_users.rb

@@ -0,0 +1,18 @@
+class CreateDashboardSettings < ActiveRecord::Migration
+
+  def up
+    unless table_exists?(:dashboard_settings)
+      create_table :dashboard_settings do |t|
+        t.references :user, index: true, foreign_key: false
+        t.string :widget
+        t.string :action
+        t.index [:widget, :action]
+      end
+    end
+  end
+
+  def down
+    drop_table :dashboard_settings if table_exists? :dashboard_settings
+  end
+
+end

data/lib/generators/templates/generic_widget.erb

@@ -0,0 +1,12 @@
+class <%= @widget_name %>Widget < ApplicationWidget
+
+  name! "<%= @widget_name %>"
+  description! "O Widget <%= @widget_name %> tem como função..."
+  #refresh_interval 60000 #60 segundos para refresh automático
+
+  description! :exemplo, 'Essa ação é um exemplo'
+  def exemplo
+    @data = Date.today
+  end
+
+end

data/lib/generators/templates/generic_widget.html.erb

@@ -0,0 +1,2 @@
+<h1>Exemplo de Widget<h1>
+Hoje é <%= data %>

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: dashboard-rails
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- TaxWeb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: Gerenciamento de Widgets para Dashboard
+email:
+- produto@taxweb.com.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- app/assets/javascripts/dashboard-rails.js
+- app/assets/stylesheets/dashboard-rails.css
+- app/controllers/application_widget.rb
+- app/controllers/dashboard-rails/application_controller.rb
+- app/controllers/dashboard-rails/widgets_controller.rb
+- app/helpers/dashboard-rails/application_helper.rb
+- app/models/dashboard-rails/user.rb
+- app/views/dashboard-rails/widgets/_widgets_list.html.erb
+- app/views/dashboard-rails/widgets/index.html.erb
+- config/initializers/assets.rb
+- config/routes.rb
+- lib/dashboard-rails.rb
+- lib/dashboard-rails/engine.rb
+- lib/dashboard-rails/singleton_helper.rb
+- lib/dashboard-rails/version.rb
+- lib/dashboard-rails/widget.rb
+- lib/generators/dashboard-rails/install_generator.rb
+- lib/generators/dashboard-rails/view_generator.rb
+- lib/generators/dashboard-rails/widget_generator.rb
+- lib/generators/templates/create_taxweb_widgets_users.rb
+- lib/generators/templates/generic_widget.erb
+- lib/generators/templates/generic_widget.html.erb
+homepage: http://www.taxweb.com.br
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.8
+signing_key: 
+specification_version: 4
+summary: Gerenciamento de Widgets para Dashboard
+test_files: []