back_office 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9d15cc3bf6faebdf066736e07a547fedf21d361a
+  data.tar.gz: 82434cdab661c38a6a47b9c311d72132df073ce7
+SHA512:
+  metadata.gz: e9ac1e61668ea1ebf67b5cc2b88034154b44460b12c3b9a17550ae9a3b4025f478c697b0a4af6969fd7abcea1abfa19feaeecf1c5eed80369ef69dd3d549af38
+  data.tar.gz: '0944bf7a5e7ecc935a3b87a7f7598a21b013a5aa8f06dfa1f9b284e0387e80516151231c54b84ad931d904ec586040bcbb83af0c2cee4b144d6499ee942dc4c0'

data/README.md

@@ -0,0 +1,28 @@
+# BackOffice
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'back_office'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install back_office
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,32 @@
+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    = 'BackOffice'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  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'
+
+require 'bundler/gem_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/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/back_office.rb

@@ -0,0 +1,22 @@
+require 'back_office/engine'
+require 'back_office/authorization'
+require 'back_office/form_builder'
+
+module BackOffice
+  THRESHOLD = 8.days
+
+  def self.verifier
+    Rails.application.message_verifier('backoffice')
+  end
+
+  def self.encrypt(value)
+    verifier.generate([value, THRESHOLD.from_now])
+  end
+
+  def self.decrypt(token)
+    value, expiration = verifier.verify(token)
+    value if expiration > Time.current
+  rescue ActiveSupport::MessageVerifier::InvalidSignature
+    nil
+  end
+end

data/lib/back_office/auth.rb

@@ -0,0 +1,61 @@
+module BackOffice
+  module Auth
+    extend ActiveSupport::Concern
+
+    included do
+      before_action :authorize
+      delegate      :current_user, to: :current_device
+      delegate      :authorized?,  to: :authorization
+      helper_method :current_user, :authorized?
+    end
+
+    private
+
+    def current_device
+      @current_device ||= Device.current(device_token, device_attributes)
+    end
+
+    def device_token
+      authenticate_with_http_token { |token, _| token } || cookies.signed[:token]
+    end
+
+    def device_attributes
+      {
+        token:      SecureRandom.urlsafe_base64,
+        user_agent: request.user_agent,
+        remote_ip:  request.remote_ip
+      }
+    end
+
+    def sign_in(user)
+      current_device.update(user: user)
+      cookies.signed[:token] = current_device.token
+    end
+
+    def sign_out
+      cookies.delete(:token)
+      session.clear
+    end
+
+    def authorize
+      return true if authorized?(controller_name, action_name, resource)
+
+      respond_to do |format|
+        format.any(:js, :json) { head :unauthorized }
+        format.html { redirect_to(root_path, alert: t(:unauthorized)) }
+      end
+    end
+
+    def authorization
+      @authorization ||= authorization_class.new(current_user)
+    end
+
+    def authorization_class
+      "#{self.class.parent_name || 'Application'}Authorization".constantize
+    end
+
+    def resource
+      nil
+    end
+  end
+end

data/lib/back_office/authorization.rb

@@ -0,0 +1,25 @@
+module BackOffice
+  class Authorization
+    def initialize(current_user)
+      raise NotImplementedError
+    end
+
+    def authorized?(controller, action, resource = nil)
+      if rule = rules.dig(controller.to_sym, action.to_sym)
+        rule == true || resource && rule.call(resource)
+      else
+        false
+      end
+    end
+
+    private
+
+    def authorize(controller, *actions, &block)
+      actions.flatten.each { |action| rules[controller][action] = (block || true) }
+    end
+
+    def rules
+      @rules ||= Hash.new { |hash, key| hash[key] = {} }
+    end
+  end
+end

data/lib/back_office/cursor.rb

@@ -0,0 +1,16 @@
+module BackOffice
+  class Cursor
+    attr_reader :scopes, :params, :options
+
+    def initialize(default_scope, params, options = {})
+      @scopes  = Hash.new(default_scope).merge!(options.delete(:scopes) || {})
+      @params  = params.permit(:scope, :query, :sort, :page, :filters).to_h
+      @options = options
+      @scope   = params[:scope].to_s
+    end
+
+    def results
+      scopes[@scope.to_sym].search(params)
+    end
+  end
+end

data/lib/back_office/engine.rb

@@ -0,0 +1,4 @@
+module BackOffice
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/back_office/form_builder.rb

@@ -0,0 +1,117 @@
+module BackOffice
+  class FormBuilder < ActionView::Helpers::FormBuilder
+    FIELD_CLASS   = 'field'.freeze
+    LABEL_CLASS   = 'label'.freeze
+    ACTION_CLASS  = 'action'.freeze
+    HINT_CLASS    = 'hint'.freeze
+    ERRORS_CLASS  = 'errors'.freeze
+    FIELD_METHODS = %w(
+      text_field
+      number_field
+      text_area
+      email_field
+      phone_field
+      password_field
+      file_field
+      collection_select
+      collection_check_boxes
+      check_box
+      date_select
+      time_zone_select
+    ).freeze
+
+    delegate :content_tag, :tag, :capture, to: :@template
+
+    FIELD_METHODS.each do |method_name|
+      define_method method_name do |name, *args, &block|
+        options = args.extract_options!
+        hint    = options.delete(:hint)
+        confirm = options.delete(:confirm)
+        classes = object.class.validators_on(name).map { |v| v.to_s.underscore }
+        content = field_label(name, options) +
+                  super(name, *args, options, &block) +
+                  discloser(method_name) +
+                  confirmation(confirm) +
+                  hint_label(hint)
+
+        content_tag(:div, content, class: classes.push(FIELD_CLASS))
+      end
+    end
+
+    def submit(value = nil, options = {}, &block)
+      content = if block
+                  block_before ? capture(&block) + super : super + capture(&block)
+                else
+                  super
+                end
+
+      content_tag(:div, content, class: ACTION_CLASS)
+    end
+
+    def field_input(confirm: false)
+      field   = object.field
+      options = { label: field.name, hint: field.hint, confirm: confirm }
+
+      case field.data_type
+      when 'string'
+        if field.options.present?
+          collection_select(:value, field.options.lines.map(&:chomp), :itself, :itself, options)
+        elsif field.scale.positive?
+          text_area(:value, options.merge(rows: field.scale))
+        else
+          text_field(:value, options)
+        end
+      when 'datetime'
+        text_field(:value, options.merge(class: 'datepicker'))
+      when 'boolean'
+        check_box(:value, options)
+      else
+        text_field(:value, options)
+      end
+    end
+
+    def confirmation(confirm)
+      check_box(:confirm, label: false, hint: false) if confirm
+    end
+
+    private
+
+    def field_label(name, options)
+      base_text = case options[:label]
+                  when false
+                    ''
+                  when nil
+                    object.class.human_attribute_name(name)
+                  else
+                    options[:label]
+                  end
+
+      if base_text.present? && object.errors[name].first
+
+
+      end
+      label_text  = label_and_error_text(name, options)
+
+      label(name, label_text, class: css_classes)
+    end
+
+    def label_and_error_text(name, options)
+      label_text = options.fetch(:label, )
+      error_text =
+
+      [label_text, error_text].compact.join(SEPARATOR)
+    end
+
+    def objectify_options(options)
+      super.except(:label)
+    end
+
+    def hint_label(text)
+      content_tag(:span, text.try(:html_safe), class: HINT_CLASS) unless text == false
+    end
+
+    def discloser(method_name, css_class = 'discloser')
+      method_name.to_s.end_with?('select') ? content_tag(:span, class: css_class) {} : ''
+    end
+  end
+end

data/lib/back_office/password.rb

@@ -0,0 +1,23 @@
+module BackOffice
+  class Password
+    include ActiveModel::Model
+
+    attr_accessor :email, :plaintext, :plaintext_confirmation
+
+    validates :plaintext, on: :update, presence: true, confirmation: true
+
+    def update(attrs)
+      self.plaintext              = attrs[:plaintext]
+      self.plaintext_confirmation = attrs[:plaintext_confirmation]
+
+      if valid?(:update)
+        user.update(password: plaintext)
+        true
+      end
+    end
+
+    def user
+      User.find_by(email: email) if email
+    end
+  end
+end

data/lib/back_office/reset.rb

@@ -0,0 +1,30 @@
+module Backoffice
+  class Reset < Password
+    attr_reader :token
+    validates   :email,          on: :create, presence: true
+    validate    :user_existence, on: :create
+
+    def self.find(token)
+      if email = Backoffice.decrypt(token)
+        new(email: email, token: token)
+      end
+    end
+
+    def to_param
+      token
+    end
+
+    def save
+      if token.nil? && valid?(:create)
+        @token = Backoffice.encrypt(email)
+        true
+      end
+    end
+
+    private
+
+    def user_existence
+      errors.add(:email, :not_registered) unless user
+    end
+  end
+end

data/lib/back_office/rest.rb

@@ -0,0 +1,136 @@
+module BackOffice
+  module Rest
+    extend  ActiveSupport::Concern
+    include Auth
+
+    def index
+      @cursor = BackOffice::Cursor.new(default_scope, params, cursor_options)
+    end
+
+    def create
+      resource.attributes = resource_params
+
+      if resource.save
+        created
+        success
+      else
+        failure
+      end
+    end
+
+    def update
+      if resource.update(resource_params)
+        updated
+        success
+      else
+        failure
+      end
+    end
+
+    def destroy
+      if resource.destroy
+        deleted
+        success
+      else
+        failure
+      end
+    end
+
+    private
+
+    def resource
+      instance_variable_get("@#{param_key}") ||
+      instance_variable_set("@#{param_key}", (find_resource || build_resource))
+    end
+
+    def param_key
+      resource_class.model_name.param_key
+    end
+
+    def find_resource
+      find_scope.find(params[:id]) if params[:id].present?
+    end
+
+    def find_scope
+      resource_class
+    end
+
+    def resource_class
+      controller_name.classify.constantize
+    end
+
+    def build_resource
+      resource_class.new(build_params)
+    end
+
+    def build_params
+      {}
+    end
+
+    def default_scope
+      resource_class.order(created_at: :desc)
+    end
+
+    def cursor_options
+      {}
+    end
+
+    def success
+      respond_to do |format|
+        format.js
+        format.json { json_success }
+        format.html { html_success }
+      end
+    end
+
+    def failure
+      respond_to do |format|
+        format.js
+        format.json { json_failure }
+        format.html { html_failure }
+      end
+    end
+
+    def html_success
+      redirect_to after_path, notice: success_notice
+    end
+
+    def json_success
+      case action_name.to_sym
+      when :create  then render :show, status: :created
+      when :update  then render :show, status: :ok
+      when :destroy then head   :ok
+      end
+    end
+
+    def html_failure
+      render(resource.new_record? ? :new : :edit)
+    end
+
+    def json_failure
+      render status: :unprocessable_entity, json: { errors: resource.errors.messages }
+    end
+
+    def resource_params
+      params.require(param_key).permit(permitted_attributes)
+    end
+
+    def permitted_attributes
+      []
+    end
+
+    def success_notice
+      nil
+    end
+
+    def after_path
+      url_for controller: controller_name, action: :index
+    end
+
+    def created; end
+
+    def updated; end
+
+    def deleted; end
+  end
+end

data/lib/back_office/searchable.rb

@@ -0,0 +1,69 @@
+module BackOffice
+  module Searchable
+    extend ActiveSupport::Concern
+
+    included do
+      include PgSearch
+      searchable_by :id
+    end
+
+    class_methods do
+      def sort_options
+        @sort_options ||= {}
+      end
+
+      def default_searchable_options
+        {
+          against: [],
+          using: { tsearch: { prefix: true } }
+        }
+      end
+
+      def searchable_by(*attrs)
+        options       = attrs.extract_options!
+        scope_options = default_searchable_options.deep_merge(options).merge!(against: attrs)
+
+        pg_search_scope(:search_by_query, scope_options)
+      end
+
+      def filterable_by(key, filter_scope = nil)
+        scope("filter_#{key}", filter_scope || ->(filter_param) { where(key => filter_param) })
+      end
+
+      def filter_with(key, value)
+        send("filter_#{key}", value)
+      end
+
+      def sortable_by(key, asc_statement, desc_statement = nil)
+        sort_options[key.to_s]  = asc_statement
+        sort_options["-#{key}"] = desc_statement || asc_statement.gsub(/ASC/i, 'DESC')
+      end
+
+      def sort_with(param)
+        sort_statement = sort_options.fetch(param) do
+          sort_parts     = param.split('-')
+          sort_direction = sort_parts.length > 1 ? 'DESC' : 'ASC'
+          sort_column    = sort_parts.last
+          sort_column    = :created_at unless column_names.include?(sort_column)
+
+          "#{table_name}.#{sort_column} #{sort_direction}"
+        end
+
+        reorder(sort_statement)
+      end
+
+      def search(params)
+        results = page(params[:page])
+
+        params.fetch(:filters, {}).each do |filter_name, filter_value|
+          results = results.filter_with(filter_name, filter_value) if filter_value.present?
+        end
+
+        results = results.search_by_query(params[:query]) if params[:query].present?
+        results = results.sort_with(params[:sort])        if params[:sort].present?
+
+        results
+      end
+    end
+  end
+end

data/lib/back_office/version.rb

@@ -0,0 +1,3 @@
+module BackOffice
+  VERSION = '0.1.0'
+end

data/lib/tasks/back_office_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :back_office do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: back_office
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gustavo Beathyate
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+description: Back Office provides base objects for building custom Rails apps.
+email:
+- gustavo.bt@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/assets/config/back_office_manifest.js
+- config/routes.rb
+- lib/back_office.rb
+- lib/back_office/auth.rb
+- lib/back_office/authorization.rb
+- lib/back_office/cursor.rb
+- lib/back_office/engine.rb
+- lib/back_office/form_builder.rb
+- lib/back_office/password.rb
+- lib/back_office/reset.rb
+- lib/back_office/rest.rb
+- lib/back_office/searchable.rb
+- lib/back_office/version.rb
+- lib/tasks/back_office_tasks.rake
+homepage: http://goddamnhippie.github.io/back_office
+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.6.9
+signing_key: 
+specification_version: 4
+summary: Back Office is a Rails engine that packs shared app functionality.
+test_files: []