egov_utils 0.1.0

data/app/models/ability.rb

@@ -0,0 +1,17 @@
+begin
+  require_dependency "#{Rails.application.class.parent_name.underscore}/roles"
+rescue LoadError => e
+  Rails.logger.warning "!! You have not defined roles."
+  Rails.logger.warning "!! Please define it in lib/#{Rails.application.class.parent_name.underscore}/roles."
+  Rails.logger.warning "!! EgovUtils roles management will not work without it."
+end
+
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    user.all_roles.each do |role|
+      role.define_abilities(self, user)
+    end
+  end
+end

data/app/models/egov_utils/address.rb

@@ -0,0 +1,79 @@
+module EgovUtils
+  class Address < ApplicationRecord
+
+    # before_safe :identify_address , if: :changed?
+
+    validates :street, :city, length: 3..255
+    validates :postcode, numericality: { only_integer: true }
+
+    District = Struct.new(:id, :name, :region_id)
+    Region = Struct.new(:id, :name)
+
+    def self.districts
+      return @districts if @districts
+      require 'csv'
+      @districts = []
+      CSV.foreach(EgovUtils::Engine.root.join('config', 'okres.csv'), col_sep: ';', headers: true) do |row|
+        @districts << District.new( row[0].to_i, row[1], row[2].to_i) if row[1]
+      end
+      @districts
+    end
+
+    def self.regions
+      return @regions if @regions
+      require 'csv'
+      @regions = []
+      CSV.foreach(EgovUtils::Engine.root.join('config', 'kraj.csv'), col_sep: ';', headers: true) do |row|
+        @regions << Region.new( row[0].to_i, row[1]) if row[1]
+      end
+      @regions
+    end
+
+    def self.region_for_district(district_name)
+      district = districts.detect{|d| d[:name] == district_name }
+      regions.detect{|r| r[:id] == district[:region_id] } if district
+    end
+
+    def district=(value)
+      self.region = self.class.region_for_district(value)[:name]
+      super
+    end
+
+    def number
+      if !house_number.blank? && !orientation_number.blank?
+        "#{house_number}/#{orientation_number}"
+      else
+        house_number.presence || orientation_number.presence
+      end
+    end
+
+    def full_address
+      to_s
+    end
+
+    def to_s
+      "#{street} #{number}, #{postcode} #{city}"
+    end
+
+    def prepare_egon_message(message)
+      message.obec_nazev = city.presence
+      message.cast_obce_nazev = city_part.presence
+      message.ulice_nazev = street.presence
+      message.posta_kod = postcode.presence
+      message.cislo_domovni = house_number.presence
+      message.cislo_orientacni = orientation_number.presence
+    end
+
+    def from_egon_info(message)
+      self.egov_identifier = message[:adresni_misto_kod]
+      self.district = message[:okres_nazev]
+      self.city = message[:obec_nazev]
+      self.city_part = message[:cast_obce_nazev]
+      self.street = message[:ulice_nazev]
+      self.postcode = message[:posta_kod]
+      self.house_number = message[:cislo_domovni]
+      self.orientation_number = message[:cislo_orientacni]+(message[:cislo_orientacni_pismeno] || '')
+    end
+
+  end
+end

data/app/models/egov_utils/application_record.rb

@@ -0,0 +1,5 @@
+module EgovUtils
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/egov_utils/audit_detail.rb_bac

@@ -0,0 +1,28 @@
+module EgovUtils
+  class AuditDetail < ApplicationRecord
+    belongs_to :audit_record
+
+    def value=(arg)
+      write_attribute :value, normalize(arg)
+    end
+
+    def old_value=(arg)
+      write_attribute :old_value, normalize(arg)
+    end
+
+    private
+
+      def normalize(v)
+        case v
+        when true
+          "1"
+        when false
+          "0"
+        when Date
+          v.strftime("%Y-%m-%d")
+        else
+          v
+        end
+      end
+  end
+end

data/app/models/egov_utils/audit_record.rb_bac

@@ -0,0 +1,98 @@
+module EgovUtils
+  class AuditRecord < ApplicationRecord
+    belongs_to :audited, :polymorphic => true
+    belongs_to :user
+
+    has_many :details, :class_name => "AuditDetail", :dependent => :delete_all, :inverse_of => :audit_record
+    attr_accessor :indice
+    attr_protected :id
+
+    after_create :send_notification
+
+    def save(*args)
+      journalize_changes
+      # Do not save an empty journal
+      (details.empty? && notes.blank?) ? false : super
+    end
+
+    # Stores the values of the attributes and custom fields of the journalized object
+    def start
+      if journalized
+        @attributes_before_change = journalized.journalized_attribute_names.inject({}) do |h, attribute|
+          h[attribute] = journalized.send(attribute)
+          h
+        end
+      end
+      self
+    end
+
+    # Adds a journal detail for an attachment that was added or removed
+    def journalize_attachment(attachment, added_or_removed)
+      key = (added_or_removed == :removed ? :old_value : :value)
+      details << JournalDetail.new(
+          :property => 'attachment',
+          :prop_key => attachment.id,
+          key => attachment.filename
+        )
+    end
+
+    private
+
+    # Generates journal details for attribute and custom field changes
+    def journalize_changes
+      # attributes changes
+      if @attributes_before_change
+        journalized.journalized_attribute_names.each {|attribute|
+          before = @attributes_before_change[attribute]
+          after = journalized.send(attribute)
+          next if before == after || (before.blank? && after.blank?)
+          add_attribute_detail(attribute, before, after)
+        }
+      end
+      if @custom_values_before_change
+        # custom fields changes
+        journalized.custom_field_values.each {|c|
+          before = @custom_values_before_change[c.custom_field_id]
+          after = c.value
+          next if before == after || (before.blank? && after.blank?)
+
+          if before.is_a?(Array) || after.is_a?(Array)
+            before = [before] unless before.is_a?(Array)
+            after = [after] unless after.is_a?(Array)
+
+            # values removed
+            (before - after).reject(&:blank?).each do |value|
+              add_custom_value_detail(c, value, nil)
+            end
+            # values added
+            (after - before).reject(&:blank?).each do |value|
+              add_custom_value_detail(c, nil, value)
+            end
+          else
+            add_custom_value_detail(c, before, after)
+          end
+        }
+      end
+      start
+    end
+
+    # Adds a journal detail for an attribute change
+    def add_attribute_detail(attribute, old_value, value)
+      add_detail('attr', attribute, old_value, value)
+    end
+
+    # Adds a journal detail
+    def add_detail(property, prop_key, old_value, value)
+      details << JournalDetail.new(
+          :property => property,
+          :prop_key => prop_key,
+          :old_value => old_value,
+          :value => value
+        )
+    end
+
+    def send_notification
+      # TODO
+    end
+  end
+end

data/app/models/egov_utils/group.rb

@@ -0,0 +1,26 @@
+require_dependency 'egov_utils/auth_source'
+module EgovUtils
+  class Group < Principal
+    validates :name, presence: true, uniqueness: true
+    validates :ldap_uid, uniqueness: true, allow_nil: true
+
+    def members
+
+    end
+
+    def ldap_members
+      Rails.cache.fetch("#{cache_key}/ldap_members", expires_in: 2.hours) do
+        if provider.present?
+          auth_source.group_members(ldap_uid)
+        else
+          []
+        end
+      end
+    end
+
+    def ldap_member?(user)
+      ldap_members.detect{|mem| mem[:login] == user.login }
+    end
+
+  end
+end

data/app/models/egov_utils/person.rb

@@ -0,0 +1,9 @@
+module EgovUtils
+  class Person < ApplicationRecord
+
+    def fullname
+      firstname.to_s + ' ' + lastname.to_s
+    end
+
+  end
+end

data/app/models/egov_utils/principal.rb

@@ -0,0 +1,20 @@
+module EgovUtils
+  class Principal < ApplicationRecord
+    self.abstract_class = true
+
+    serialize :roles, Array
+
+    def reload(*attrs)
+      @auth_source = nil
+      super
+    end
+
+    def has_role?(role)
+      roles.include?(role)
+    end
+
+    def auth_source
+      @auth_source ||= EgovUtils::AuthSource.new(provider) if provider.present?
+    end
+  end
+end

data/app/models/egov_utils/user.rb

@@ -0,0 +1,108 @@
+require_dependency 'egov_utils/auth_source'
+require 'request_store_rails'
+
+module EgovUtils
+  class User < Principal
+    has_secure_password validations: false
+
+    serialize :roles, Array
+
+    validates :login, uniqueness: true
+
+    scope :active, -> { where(active: true) }
+    scope :inactive, -> { where(active: false) }
+
+    def self.authenticate(login, password, active_only=true)
+      login = login.to_s
+      password = password.to_s
+
+      # Make sure no one can sign in with an empty login or password
+      return nil if login.empty? || password.empty?
+      user = find_by(login: login) || find_by(mail: login)
+      if user
+        # user is already in local database
+        return nil unless user.password_check?(password)
+        return nil if active_only && !user.active?
+      else
+        # user is not yet registered, try to authenticate with available sources
+        attrs = EgovUtils::AuthSource.authenticate(login, password)
+        if attrs
+          user = new(attrs.merge(active: true))
+          if user.ldap_register_allowed? && user.save
+            user.reload
+            logger.info("User '#{user.login}' created from external auth source: #{user.provider}") if logger && user.auth_source
+          end
+        end
+      end
+      user.update_column(:last_login_at, Time.now) if user && !user.new_record? && user.active?
+      user
+    end
+
+    def self.anonymous
+      self.new
+    end
+
+    def self.current=(user)
+      RequestLocals.store[:current_user] = user || anonymous
+    end
+
+    def self.current
+      RequestLocals.fetch(:current_user) { User.anonymous }
+    end
+
+    def roles
+      logged? ? super : ['anonymous']
+    end
+
+    def ldap_register_allowed?
+      auth_source && auth_source.register_members_only? && ldap_groups.any?
+    end
+
+    def password_check?(password)
+      if provider.present?
+        auth_source.authenticate(login, password)
+      else
+        authenticate(password)
+      end
+    end
+
+    def logged?
+      persisted?
+    end
+
+    def locked?
+      false
+    end
+
+    def fullname
+      "#{firstname} #{lastname}"
+    end
+
+    def admin?
+      has_role?('admin')
+    end
+
+    def has_role?(role_name)
+      all_role_names.include?(role_name)
+    end
+
+    def all_role_names
+      @all_role_names ||= groups.collect{|g| g.roles}.reduce([], :concat) + roles
+    end
+
+    def all_roles
+      all_role_names.map{|rn| EgovUtils::UserUtils::Role.find(rn) }.compact.collect{|cls| cls.new }
+    end
+
+    def groups
+      ldap_groups || []
+    end
+
+    def ldap_groups
+      if provider.present?
+        EgovUtils::Group.where(provider: provider).to_a.select{|g| g.ldap_member?(self) }
+      end
+    end
+
+  end
+end

data/app/schemas/egov_utils/address_schema.rb

@@ -0,0 +1,30 @@
+module EgovUtils
+  class AddressSchema < AzaharaSchema::ModelSchema
+
+    def attribute_for_column(col)
+      case col.name
+      when 'district'
+        EgovUtils::District.new
+      when 'region'
+        EgovUtils::Region.new
+      else
+        super
+      end
+    end
+
+    def main_attribute_name
+      'full_address'
+    end
+
+    def path
+      'to_s'
+    end
+
+    def initialize_available_attributes
+      @available_attributes ||= []
+      @available_attributes << FullAddress.new
+      super
+    end
+
+  end
+end

data/app/validators/email_validator.rb

@@ -0,0 +1,8 @@
+class EmailValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return if options[:allow_nil] && value.presence.nil?
+    unless value =~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i
+      record.errors.add(attribute, (options[:message] || :email_format))
+    end
+  end
+end

data/app/validators/ico_validator.rb

@@ -0,0 +1,7 @@
+class IcoValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    unless !value.nil? && value =~ /\A\d{7,9}\z/
+      record.errors.add(attribute, (options[:message] || :ico_format))
+    end
+  end
+end

data/app/views/common/_grid.html.coffee

@@ -0,0 +1,130 @@
+$ ->
+  <%
+    grid ||= schema.outputs.grid
+    additional_params ||= {}
+  %>
+
+  $('body').off 'egov:submitted'
+  $('body').on 'egov:submitted', '#modal', (evt, data)->
+    grid = $("#<%= grid_id %>").swidget()
+    grid.dataSource.read()
+
+  <%# would be a bit cleaner to give the filled form to the shield grid create method, then send the form by ajax %>
+  createRecord = (evt)->
+    $.ajax('<%= new_polymorphic_path(schema.model, format: :js) %>')
+
+
+  editRecord = (index)->
+    grid = $("#<%= grid_id %>").swidget()
+    item = grid.dataItem(index)
+    $.ajax('<%= polymorphic_path(schema.model) %>/'+item.id+'/edit.js')
+
+<% if local_assigns[:detail_for] %>
+  <% detail_col = schema.column(detail_for) %>
+  detailCreated = (evt)->
+    $("<div/>").appendTo(evt.detailCell).shieldGrid
+      dataSource:
+        remote:
+          read:
+            type: 'GET'
+            url: '<%= polymorphic_path(schema.model) %>/'+evt.item.id+'<%= polymorphic_path(detail_for, format: :json) %>'
+            dataType: 'json'
+      paging:
+        pageSize: 5
+      columns: [
+        <% detail_col.schema.columns.each do |col| %>
+        <%= raw column_for_grid(detail_col.schema.outputs.grid, col) %>
+        <% end %>
+      ]
+<% end %>
+
+  $('#<%= grid_id %>').shieldGrid({
+    noRecordsText: '<%= t('label_no_records') %>'
+    dataSource: {
+      schema:
+        fields:
+          <% schema.available_columns.each do |column| %>
+          <%= raw field_for_grid(column) %>
+          <% end %>
+      events:
+        error: (event) ->
+          if event.errorType == 'transport'
+            alert("Write error: " + event.error.statusText )
+            if event.operation == 'save'
+              this.read()
+          else
+            alert( event.errorType + " error: " + event.error )
+      remote: {
+        read: {
+          type: 'GET'
+          url: '<%= polymorphic_path(schema.model, schema.to_param.merge(additional_params).merge(format: :json)) %>'
+          dataType: 'json'
+        }
+        modify: {
+          create: (items, success, error) ->
+            newItem = items[0]
+            $.ajax
+              url: '<%= polymorphic_path(schema.model, format: :json) %>'
+              type: 'POST'
+              dataType: 'json'
+              data: { <%= grid.model_name.name.underscore %>: newItem.data }
+              complete: (xhr) ->
+                if xhr.readyState == 4 and xhr.status == 201
+                  newItem.data.id = xhr.responseJSON.id
+                  success()
+                  return
+                error(xhr)
+          # remove: (items, success, error) ->
+          #   $.ajax(
+          #     type: "DELETE"
+          #     url: "<%= polymorphic_path(schema.model) %>/" + items[0].data.id + '.json'
+          #     dataType: 'json'
+          #   ).then(success, error)
+        }
+        operations: ['sort']
+      }
+    },
+    columns: [
+      <% schema.columns.each do |col| %>
+      <%= raw column_for_grid(grid, col) %>
+      <% end %>
+      <% if can?(:update, schema.model) || can?(:destroy, schema.model) %>
+      {
+        width: 150
+        title: " "
+        buttons: [
+          <% if can?(:update, schema.model) %>
+          {cls: 'btn btn-sm btn-primary', caption: '<%= t('label_edit') %>', click: editRecord}
+          <% end %>
+          # <% if can?(:destroy, schema.model) %>
+          # {commandName: 'delete', caption: '<%= t('label_delete') %>'}
+          # <% end %>
+        ]
+      }
+      <% end %>
+    ],
+    sorting:
+      multiple: false
+    editing:
+      enabled: <%= can?(:update, schema.model) || can?(:destroy, schema.model) %>
+      type: 'row'
+    <% if local_assigns[:detail_for] %>
+    events:
+      detailCreated: detailCreated
+    <% end %>
+    <% if can? :create, schema.model %>
+    toolbar: [
+      {
+        buttons: [
+          { cls: 'btn btn-primary', caption: '<%= t('helpers.submit.create', model: grid.model_name.human) %>', click: createRecord }
+        ],
+        position: 'top'
+      }
+    ]
+    <% end %>
+  });
+
+  destroy_evt_method = (evt)->
+    $('#<%= grid_id %>').shieldGrid('destroy')
+    $(document).off 'turbolinks:before-cache', destroy_evt_method
+  $(document).on 'turbolinks:before-cache', destroy_evt_method

data/app/views/common/_modal.html.haml

@@ -0,0 +1,11 @@
+#modal.modal.fade
+  .modal-dialog{ role: "document" }
+    .modal-content
+      .modal-header
+        %h5.modal-title Modal
+        %button.close{ 'type' => "button", 'data-dismiss'=>"modal", 'aria-label'=>"Close" }
+          %span{'aria-hidden'=> true } ×
+      .modal-body
+      .modal-footer
+        /<button type="button" class="btn btn-primary">Save changes</button>
+        /<button type="button" class="btn btn-secondary" data-dismiss="modal">Close</button>

data/app/views/egov_utils/addresses/_form.html.haml

@@ -0,0 +1,51 @@
+.row.address-fields
+  = form.hidden_field :egov_identifier
+  .col-6
+    = form.text_field :street
+  .col-3
+    = form.text_field :house_number
+  .col-3
+    = form.text_field :orientation_number
+  .col-12
+    = form.text_field :city
+    = form.text_field :postcode
+    = form.text_field :district
+    = form.select :region, EgovUtils::Address.regions.collect{|r| [r[:name],r[:name]]}
+    -# form.text_field :country
+    %div.validation-button
+      = link_to t('label_find'), 'javascript:void(0)', class: 'btn btn-secondary address-validator-btn'
+
+:javascript
+  $(function(){
+    $('.address-validator-btn').not('.validator-initialized').on('click', function(evt) {
+      var values = {},
+          $fields = $(this).closest('.address-fields');
+
+      $fields.find(':input').each(function(i){
+        var name,
+            name_m = $(this).attr('name').match(/\[([^\[]*)\]$/);
+        name = name_m[1];
+        values[name] = $(this).val();
+      });
+      $.ajax('#{egov_utils.validate_ruian_path}', {
+        method: 'GET',
+        dataType: 'json',
+        data: {
+          address: values
+        }
+      }).done(function(json){
+        var field;
+        for( var key in json ) {
+          field = $fields.find("[name$='["+key+"]']");
+          if( field.length !== 1 || !json[key] )
+            continue;
+          field.val(json[key]);
+        }
+      }).fail(function(xhr, status, errorMsg){
+        $('#modal').modal('hide');
+        eGovUtilities.showModal(xhr.responseJSON.error, {modalId: 'modalAlert', backdrop: 'static'}).on('hidden.bs.modal', function(){
+          $('#modal').modal('show');
+        });
+      });
+    }).addClass('.validator-initialized');
+  });

data/app/views/egov_utils/people/_form.html.haml

@@ -0,0 +1,3 @@
+= form.text_field(:firstname)
+= form.text_field(:lastname)
+= form.date_field(:birth_date)

data/app/views/egov_utils/roles/index.html.haml

@@ -0,0 +1,29 @@
+%h3= EgovUtils::User.model_name.human(count: :other)
+%table#user_roles.table
+  %thead
+    %tr
+      %th= EgovUtils::User.human_attribute_name('fullname')
+      %th= EgovUtils::User.human_attribute_name('roles')
+  %tbody
+    - @users.each do |user|
+      %tr
+        %td= user.fullname
+        %td.roles{data: {roles: user.roles, id: user.id}}= user.roles.join(', ')
+
+%h3= EgovUtils::Group.model_name.human(count: :other)
+%table#group_roles.table
+  %thead
+    %tr
+      %th= EgovUtils::Group.human_attribute_name('name')
+      %th= EgovUtils::Group.human_attribute_name('roles')
+  %tbody
+    - @groups.each do |group|
+      %tr
+        %td= group.name
+        %td.roles{data: {roles: group.roles, id: group.id}}= group.roles.join(', ')
+
+:javascript
+  $(function(){
+    $('#user_roles tbody').roles({ url: '#{roles_path(entity_class: 'EgovUtils::User')}' });
+    $('#group_roles tbody').roles({ url: '#{roles_path(entity_class: 'EgovUtils::Group')}' });
+  });

data/app/views/egov_utils/sessions/new.html.haml

@@ -0,0 +1,5 @@
+= bootstrap_form_for(:session) do |f|
+  = f.text_field(:username)
+  = f.password_field(:password)
+  = f.submit
+-# link_to t('label_register'), new_user_path

data/app/views/egov_utils/users/_form.html.haml

@@ -0,0 +1,6 @@
+= form.text_field :login
+= form.text_field :mail
+= form.password_field :password
+= form.password_field :password_confirmation
+= form.text_field :firstname
+= form.text_field :lastname