solidus_br_common 1.1.0

data/app/assets/javascripts/spree/frontend/plugins/jquery.mask.js

@@ -0,0 +1,395 @@
+/**
+ * jquery.mask.js
+ * @version: v1.6.5
+ * @author: Igor Escobar
+ *
+ * Created by Igor Escobar on 2012-03-10. Please report any bug at http://blog.igorescobar.com
+ *
+ * Copyright (c) 2012 Igor Escobar http://blog.igorescobar.com
+ *
+ * The MIT License (http://www.opensource.org/licenses/mit-license.php)
+ *
+ * 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.
+ */
+/*jshint laxbreak: true */
+/* global define */
+
+// UMD (Universal Module Definition) patterns for JavaScript modules that work everywhere.
+// https://github.com/umdjs/umd/blob/master/jqueryPlugin.js
+(function (factory) {
+    if (typeof define === "function" && define.amd) {
+        // AMD. Register as an anonymous module.
+        define(["jquery"], factory);
+    } else {
+        // Browser globals
+        factory(window.jQuery || window.Zepto);
+    }
+}(function ($) {
+    "use strict";
+    var Mask = function (el, mask, options) {
+        var jMask = this, old_value, regexMask;
+        el = $(el);
+
+        mask = typeof mask === "function" ? mask(el.val(), undefined, el,  options) : mask;
+
+        jMask.init = function() {
+            options = options || {};
+
+            jMask.byPassKeys = [9, 16, 17, 18, 36, 37, 38, 39, 40, 91];
+            jMask.translation = {
+                '0': {pattern: /\d/},
+                '9': {pattern: /\d/, optional: true},
+                '#': {pattern: /\d/, recursive: true},
+                'A': {pattern: /[a-zA-Z0-9]/},
+                'S': {pattern: /[a-zA-Z]/}
+            };
+
+            jMask.translation = $.extend({}, jMask.translation, options.translation);
+            jMask = $.extend(true, {}, jMask, options);
+
+            regexMask = p.getRegexMask();
+
+            el.each(function() {
+                if (options.maxlength !== false) {
+                    el.attr('maxlength', mask.length);
+                }
+
+                if (options.placeholder) {
+                    el.attr('placeholder' , options.placeholder);
+                }
+                
+                el.attr('autocomplete', 'off');
+                p.destroyEvents();
+                p.events();
+                
+                var caret = p.getCaret();
+
+                p.val(p.getMasked());
+                p.setCaret(caret + p.getMaskCharactersBeforeCount(caret, true));
+            });
+
+
+        };
+
+        var p = {
+            getCaret: function () {
+                var sel,
+                    pos = 0,
+                    ctrl = el.get(0),
+                    dSel = document.selection,
+                    cSelStart = ctrl.selectionStart;
+
+                // IE Support
+                if (dSel && !~navigator.appVersion.indexOf("MSIE 10")) {
+                    sel = dSel.createRange();
+                    sel.moveStart('character', el.is("input") ? -el.val().length : -el.text().length);
+                    pos = sel.text.length;
+                }
+                // Firefox support
+                else if (cSelStart || cSelStart === '0') {
+                    pos = cSelStart;
+                }
+                
+                return pos;
+            },
+            setCaret: function(pos) {
+                if (el.is(":focus")) {
+                    var range, ctrl = el.get(0);
+
+                    if (ctrl.setSelectionRange) {
+                        ctrl.setSelectionRange(pos,pos);
+                    } else if (ctrl.createTextRange) {
+                        range = ctrl.createTextRange();
+                        range.collapse(true);
+                        range.moveEnd('character', pos);
+                        range.moveStart('character', pos);
+                        range.select();
+                    }
+                }
+            },
+            events: function() {
+                el.on('keydown.mask', function() {
+                    old_value = p.val();
+                });
+                el.on('keyup.mask', p.behaviour);
+                el.on("paste.mask drop.mask", function() {
+                    setTimeout(function() {
+                        el.keydown().keyup();
+                    }, 100);
+                });
+                el.on("change.mask", function() {
+                    el.data("changeCalled", true);
+                });
+                el.on("blur.mask", function(e){
+                    var el = $(e.target);
+                    if (el.prop("defaultValue") !== el.val()) {
+                        el.prop("defaultValue", el.val());
+                        if (!el.data("changeCalled")) {
+                            el.trigger("change");
+                        }
+                    }
+                    el.data("changeCalled", false);
+                });
+
+                // clear the value if it not complete the mask
+                el.on("focusout.mask", function() {
+                    if (options.clearIfNotMatch && !regexMask.test(p.val())) {
+                       p.val('');
+                   }
+                });
+            },
+            getRegexMask: function() {
+                var maskChunks = [], translation, pattern, optional, recursive, oRecursive, r;
+
+                for (var i = 0; i < mask.length; i++) {
+                    translation = jMask.translation[mask[i]];
+
+                    if (translation) {
+                        
+                        pattern = translation.pattern.toString().replace(/.{1}$|^.{1}/g, "");
+                        optional = translation.optional;
+                        recursive = translation.recursive;
+                        
+                        if (recursive) {
+                            maskChunks.push(mask[i]);
+                            oRecursive = {digit: mask[i], pattern: pattern};
+                        } else {
+                            maskChunks.push((!optional && !recursive) ? pattern : (pattern + "?"));
+                        }
+
+                    } else {
+                        maskChunks.push("\\" + mask[i]);
+                    }
+                }
+                
+                r = maskChunks.join("");
+                
+                if (oRecursive) {
+                    r = r.replace(new RegExp("(" + oRecursive.digit + "(.*" + oRecursive.digit + ")?)"), "($1)?")
+                         .replace(new RegExp(oRecursive.digit, "g"), oRecursive.pattern);
+                }
+
+                return new RegExp(r);
+            },
+            destroyEvents: function() {
+                el.off('keydown.mask keyup.mask paste.mask drop.mask change.mask blur.mask focusout.mask').removeData("changeCalled");
+            },
+            val: function(v) {
+                var isInput = el.is('input');
+                return arguments.length > 0 
+                    ? (isInput ? el.val(v) : el.text(v)) 
+                    : (isInput ? el.val() : el.text());
+            },
+            getMaskCharactersBeforeCount: function(index, onCleanVal) {
+                for (var count = 0, i = 0, maskL = mask.length; i < maskL && i < index; i++) {
+                    if (!jMask.translation[mask.charAt(i)]) {
+                        index = onCleanVal ? index + 1 : index;
+                        count++;
+                    }
+                }
+                return count;
+            },
+            determineCaretPos: function (originalCaretPos, oldLength, newLength, maskDif) {
+                var translation = jMask.translation[mask.charAt(Math.min(originalCaretPos - 1, mask.length - 1))];
+
+                return !translation ? p.determineCaretPos(originalCaretPos + 1, oldLength, newLength, maskDif)
+                                    : Math.min(originalCaretPos + newLength - oldLength - maskDif, newLength);
+            },
+            behaviour: function(e) {
+                e = e || window.event;
+                var keyCode = e.keyCode || e.which;
+
+                if ($.inArray(keyCode, jMask.byPassKeys) === -1) {
+
+                    var caretPos = p.getCaret(),
+                        currVal = p.val(),
+                        currValL = currVal.length,
+                        changeCaret = caretPos < currValL,
+                        newVal = p.getMasked(),
+                        newValL = newVal.length,
+                        maskDif = p.getMaskCharactersBeforeCount(newValL - 1) - p.getMaskCharactersBeforeCount(currValL - 1);
+                   
+                    if (newVal !== currVal) {
+                        p.val(newVal);
+                    }
+
+                    // change caret but avoid CTRL+A
+                    if (changeCaret && !(keyCode === 65 && e.ctrlKey)) {
+                        // Avoid adjusting caret on backspace or delete
+                        if (!(keyCode === 8 || keyCode === 46)) {
+                            caretPos = p.determineCaretPos(caretPos, currValL, newValL, maskDif);
+                        }
+                        p.setCaret(caretPos);
+                    }
+
+                    return p.callbacks(e);
+                }
+            },
+            getMasked: function (skipMaskChars) {
+                var buf = [],
+                    value = p.val(),
+                    m = 0, maskLen = mask.length,
+                    v = 0, valLen = value.length,
+                    offset = 1, addMethod = "push",
+                    resetPos = -1,
+                    lastMaskChar,
+                    check;
+
+                if (options.reverse) {
+                    addMethod = "unshift";
+                    offset = -1;
+                    lastMaskChar = 0;
+                    m = maskLen - 1;
+                    v = valLen - 1;
+                    check = function () {
+                        return m > -1 && v > -1;
+                    };
+                } else {
+                    lastMaskChar = maskLen - 1;
+                    check = function () {
+                        return m < maskLen && v < valLen;
+                    };
+                }
+
+                while (check()) {
+                    var maskDigit = mask.charAt(m),
+                        valDigit = value.charAt(v),
+                        translation = jMask.translation[maskDigit];
+
+                    if (translation) {
+                        if (valDigit.match(translation.pattern)) {
+                            buf[addMethod](valDigit);
+                             if (translation.recursive) {
+                                if (resetPos === -1) {
+                                    resetPos = m;
+                                } else if (m === lastMaskChar) {
+                                    m = resetPos - offset;
+                                }
+
+                                if (lastMaskChar === resetPos) {
+                                    m -= offset;
+                                }
+                            }
+                            m += offset;
+                        } else if (translation.optional) {
+                            m += offset;
+                            v -= offset;
+                        }
+                        v += offset;
+                    } else {
+                        if (!skipMaskChars) {
+                            buf[addMethod](maskDigit);
+                        }
+                        
+                        if (valDigit === maskDigit) {
+                            v += offset;
+                        }
+
+                        m += offset;
+                    }
+                }
+                
+                var lastMaskCharDigit = mask.charAt(lastMaskChar);
+                if (maskLen === valLen + 1 && !jMask.translation[lastMaskCharDigit]) {
+                    buf.push(lastMaskCharDigit);
+                }
+                
+                return buf.join("");
+            },
+            callbacks: function (e) {
+                var val = p.val(),
+                    changed = p.val() !== old_value;
+                if (changed === true) {
+                    if (typeof options.onChange === "function") {
+                        options.onChange(val, e, el, options);
+                    }
+                }
+
+                if (changed === true && typeof options.onKeyPress === "function") {
+                    options.onKeyPress(val, e, el, options);
+                }
+
+                if (typeof options.onComplete === "function" && val.length === mask.length) {
+                    options.onComplete(val, e, el, options);
+                }
+            }
+        };
+
+        // public methods
+        jMask.remove = function() {
+            var caret = p.getCaret(),
+                maskedCharacterCountBefore = p.getMaskCharactersBeforeCount(caret);
+
+            p.destroyEvents();
+            p.val(jMask.getCleanVal()).removeAttr('maxlength');
+            p.setCaret(caret - maskedCharacterCountBefore);
+        };
+
+        // get value without mask
+        jMask.getCleanVal = function() {
+           return p.getMasked(true);
+        };
+
+        jMask.init();
+    };
+
+    $.fn.mask = function(mask, options) {
+        this.unmask();
+        return this.each(function() {
+            $(this).data('mask', new Mask(this, mask, options));
+        });
+    };
+
+    $.fn.unmask = function() {
+        return this.each(function() {
+            try {
+                $(this).data('mask').remove();
+            } catch (e) {}
+        });
+    };
+
+    $.fn.cleanVal = function() {
+        return $(this).data('mask').getCleanVal();
+    };
+
+    // looking for inputs with data-mask attribute
+    $('*[data-mask]').each(function() {
+        var input = $(this),
+            options = {},
+            prefix = "data-mask-";
+
+        if (input.attr(prefix + 'reverse') === 'true') {
+            options.reverse = true;
+        }
+
+        if (input.attr(prefix + 'maxlength') === 'false') {
+            options.maxlength = false;
+        }
+
+        if (input.attr(prefix + 'clearifnotmatch') === 'true') {
+            options.clearIfNotMatch = true;
+        }
+
+        input.mask(input.attr('data-mask'), options);
+    });
+
+}));

data/app/assets/javascripts/spree/frontend/routes.js.erb

@@ -0,0 +1,4 @@
+Spree.routes.cities_search = Spree.pathFor('api/cities');
+Spree.routes.address_show = function (cep) {
+  return Spree.pathFor('addresses/' + cep);
+};

data/app/assets/javascripts/spree/frontend/solidus_br_common.js

@@ -0,0 +1 @@
+//= require_tree .

data/app/assets/stylesheets/spree/backend/solidus_br_common.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/backend/all.css'
+*/

data/app/assets/stylesheets/spree/frontend/solidus_br_common.css

@@ -0,0 +1,4 @@
+/*
+Placeholder manifest file.
+the installer will append this file to the app vendored assets here: 'vendor/assets/stylesheets/spree/frontend/all.css'
+*/

data/app/controllers/spree/addresses_controller.rb

@@ -0,0 +1,24 @@
+require 'rest-client'
+
+module Spree
+  class AddressesController < Spree::BaseController
+    def show
+      respond_to do |format|
+        format.json { render json: JSON.parse(find_address) }
+      end
+    rescue ::RestClient::ResourceNotFound
+      respond_to do |format|
+        format.json { render json: nil, status: :not_found }
+      end
+    end
+
+    private
+    def find_address
+      ::RestClient.get "http://api.postmon.com.br/v1/cep/#{permitted_params}"
+    end
+
+    def permitted_params
+      params.require(:cep)
+    end
+  end
+end

data/app/controllers/spree/api/cities_controller.rb

@@ -0,0 +1,33 @@
+module Spree
+  module Api
+    class CitiesController < Spree::Api::BaseController
+      skip_before_action :authenticate_user
+
+      def index
+        @cities = scope.ransack(params[:q]).result.
+          includes(:state).order(name: :asc).
+          page(params[:page]).per(params[:per_page])
+
+        city = City.order(updated_at: :asc).last
+        if stale?(city)
+          respond_with(@cities)
+        end
+      end
+
+      def show
+        @city = scope.find(params[:id])
+        respond_with(@city)
+      end
+
+      private
+      def scope
+        if params[:state_id]
+          @state = State.accessible_by(current_ability, :read).find(params[:state_id])
+          return @state.cities.accessible_by(current_ability, :read)
+        else
+          return City.accessible_by(current_ability, :read)
+        end
+      end
+    end
+  end
+end

data/app/controllers/spree/user_registrations_controller_decorator.rb

@@ -0,0 +1,13 @@
+Spree::UserRegistrationsController.class_eval do
+  include Spree::BaseHelper
+  before_action :parse_date_of_birth, :only => [:create, :update]
+
+  protected
+
+  def parse_date_of_birth
+    params[:spree_user][:date_of_birth] = DateTime.strptime(
+      params[:spree_user][:date_of_birth],
+      Spree.t('date_picker.format', default: '%Y/%m/%d')
+    ) rescue ''
+  end
+end

data/app/helpers/spree/api/api_helpers_decorator.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Api
+    module ApiHelpers
+      mattr_reader :city_attributes
+
+      @@city_attributes = [:id, :name, :ibge_code, :state_id]
+    end
+  end
+end

data/app/helpers/spree/base_helper_decorator.rb

@@ -0,0 +1,5 @@
+Spree::BaseHelper.class_eval do
+  def datepicker_value(model, field)
+    l(model[field], :format => Spree.t('date_picker.format', default: '%Y/%m/%d')) if model && model.respond_to?(field) && model[field]
+  end
+end

data/app/models/spree/ability_decorator.rb

@@ -0,0 +1,21 @@
+require 'cancan'
+
+module Spree
+  class AbilityDecorator
+    include CanCan::Ability
+
+    def initialize(user)
+      user ||= Spree.user_class.new
+
+      if user.respond_to?(:has_spree_role?) && user.has_spree_role?('admin')
+        can :manage, :all
+      else
+        can [:index, :read], City
+      end
+
+    end
+
+  end
+end
+
+Spree::Ability.register_ability(Spree::AbilityDecorator)

data/app/models/spree/address_decorator.rb

@@ -0,0 +1,6 @@
+Spree::Address.class_eval do
+  belongs_to :city, class_name: 'Spree::City'
+
+  validates :number, :numericality => {greater_than: 0}, :presence => true
+  validates :district, length: { maximum: 150}, presence: true
+end

data/app/models/spree/city.rb

@@ -0,0 +1,7 @@
+module Spree
+  class City < ActiveRecord::Base
+    belongs_to :state, class_name: 'Spree::State'
+
+    validates_presence_of :state, :ibge_code, :name
+  end
+end

data/app/models/spree/permitted_attributes_decorator.rb

@@ -0,0 +1,8 @@
+module Spree
+  module PermittedAttributes
+    class << self
+      @@address_attributes.push :city_id, :district, :number
+      @@user_attributes.push :first_name, :last_name, :cpf, :phone, :alternative_phone, :date_of_birth
+    end
+  end
+end

data/app/models/spree/state_decorator.rb

@@ -0,0 +1,3 @@
+Spree::State.class_eval do
+  has_many :cities, -> { order('name ASC') }, dependent: :destroy
+end

data/app/models/spree/user_decorator.rb

@@ -0,0 +1,52 @@
+require 'cpf_cnpj'
+require 'validates_timeliness'
+
+Spree::User.class_eval do
+
+  validates_presence_of :phone
+  validates :date_of_birth,
+            presence: true,
+            timeliness: {
+              on_or_before: lambda { 18.years.ago.at_end_of_day },
+              on_or_after: lambda { 100.years.ago.at_midnight },
+              type: :datetime
+            }
+  validates :cpf, presence: true
+  validates :first_name, :last_name, presence: true, length: {maximum: 100}
+  validates :phone, :alternative_phone, length: {maximum: 11}
+  validate :valid_cpf
+
+  before_validation :sanitize_fields
+
+  def full_name
+    "#{first_name} #{last_name}"
+  end
+
+  def cpf_formatted
+    CPF::Formatter.format(cpf)
+  end
+
+  def phone_area_code
+    phone[0..1] if phone
+  end
+
+  def phone_number
+    phone[2..-1] if phone
+  end
+
+  private
+
+  def sanitize(*fields)
+    fields.each do |field|
+      self[field] = self[field].to_s.gsub(/[^\d]/, '') if self.respond_to?(field)
+    end
+  end
+
+  def sanitize_fields
+    sanitize(:cpf, :phone, :alternative_phone)
+  end
+
+  def valid_cpf
+    errors.add(:cpf, Spree.t(:invalid)) unless CPF.valid?(cpf)
+  end
+end

data/app/overrides/spree/address/_form/add_district.html.erb.deface

@@ -0,0 +1,5 @@
+<!-- insert_after '[data-erb-id*="address2"]' -->
+<p class="form-group" id=<%="#{address_id}district" %>>
+  <%= form.label :district, Spree.t(:district) %><span class="required">*</span><br />
+  <%= form.text_field :district, class: 'form-control required ajax-loading' %>
+</p>

data/app/overrides/spree/address/_form/add_number.html.erb.deface

@@ -0,0 +1,5 @@
+<!-- insert_before '[data-erb-id*="address2"]' -->
+<p class="form-group" id=<%="#{address_id}number" %>>
+  <%= form.label :number, Spree.t(:number) %><span class="required">*</span><br />
+  <%= form.number_field :number, class: 'form-control required ajax-loading' %>
+</p>

data/app/overrides/spree/address/_form/hide_country.html.erb.deface

@@ -0,0 +1,4 @@
+<!-- replace 'p[data-erb-id*="country"]' -->
+<p class="form-group" id=<%="#{address_id}country" %>>
+  <%= form.hidden_field :country_id %>
+</p>

data/app/overrides/spree/address/_form/move_city_to_after_state.deface

@@ -0,0 +1,2 @@
+cut 'p[data-erb-id*="city"]'
+insert_after 'p[data-erb-id*="state"]'

data/app/overrides/spree/address/_form/move_zipcode_after_last_name.deface

@@ -0,0 +1,2 @@
+cut 'p[data-erb-id*="zipcode"]'
+insert_after 'p[data-erb-id*="lastname"]'

data/app/overrides/spree/address/_form/replace_city_input_text_by_select.html.erb.deface

@@ -0,0 +1,18 @@
+<!-- replace 'p[data-erb-id*="city"]' -->
+<p class="form-group" id=<%="#{address_id}city" %>>
+  <%= form.label :city, Spree.t(:city) %><span class="required">*</span><br />
+  <%= form.collection_select(
+              :city_id, address.state ? address.state.cities : [],
+              :id, :name,
+              {:include_blank => false},
+              {:class => 'form-control required'}
+      ) %>
+
+  <% unless address.state %>
+    <script>
+      $(function() {
+          Spree.updateCity('b');
+      });
+    </script>
+  <% end %>
+</p>

data/app/overrides/spree/address/_form/set_data_uf_to_state.html.erb.deface

@@ -0,0 +1,15 @@
+<!-- replace 'erb:contains("state_elements = [")' -->
+<% states =  address.country.states.map{ |s| [s.name, s.id, {'data-uf'=>s.abbr}]} %>
+<% state_elements = [
+  form.select(
+    :state_id,
+    options_for_select(states, address.state ? address.state.id: nil),
+    {:include_blank => false},
+    {:class => 'ajax-loading form-control ' + (have_states ? 'required' : 'hidden'),
+    :disabled => !have_states}
+  ) +
+  form.text_field(:state_name,
+                  :class => !have_states ? 'form-control required' : 'form-control hidden',
+                  :disabled => have_states)
+  ].join.gsub('"', "'").gsub("\n", "")
+%>