gdpr_rails 0.1.0 → 0.2.0

data/config/locales/es.yml

@@ -0,0 +1,122 @@
+es:
+  terms_app:
+    title: PolicyManager
+    sub_title: PolicyManager
+    sign_out: Salir
+    menu:
+      policies: Políticas
+      portability_requests: Solicitudes de portabilidad
+      user_portability_requests: Mis solicitudes de portabilidad
+      user_pending_policies: Mis políticas pendientes
+    misc:
+      back: Atras
+      edit: Editar
+      show: Ver
+      save: Guardar
+      download: Descargar
+      are_you_sure: ¿Estás seguro?
+    states:
+      draft: Borrador
+      published: Publicado
+    categories:
+      index:
+        title: Políticas
+        table:
+          name: Nombre
+          terms: Términos
+          show: Ver
+      show:
+        title: "Términos de política %{name}"
+        new: Nuevo término
+        table:
+          id: Id
+          content: Contenido
+          state: Estado
+          updated_at: Fecha de actualización
+          show: Ver
+    terms:
+      index:
+        title: Términos
+        button: Nuevo término
+        table:
+          description: Descripción
+          category: Politica
+          updated_at: Fecha de actualización
+          show: Ver
+          edit: Editar
+          destroy: Eliminar
+      new:
+        title: Nuevo término para %{name}
+        state: Estado
+        description: Descripción
+        button: Crear término
+        error: al guardar término
+        created: Término creado correctamente
+        updated: Término actualizado correctamente
+        destroyed: Término eliminado correctamente
+      edit:
+        title: Editar término %{name}
+        state: Estado
+        description: Descripción
+        error: al guardar término
+      show:
+        title: Término
+        last_update: Última actualización
+        table:
+          name: Nombre
+          terms: Términos
+          show: Ver
+    user_terms:
+      pending:
+        title: Mis politicas pendientes de aceptar
+        empty: No existen politicas por aceptar
+      show:
+        accepted:
+          message: Esta politica ya ha sido aceptada
+          question: ¿Deseas cambiar tu elección?
+          reject: Rechazar
+          not_now: No por ahora
+        pending:
+          message: por favor acepta esta politica
+          agree: Acepto
+          not_now: No por ahora
+    user_portability_requests:
+      index:
+        title: Mis solicitudes de portabilidad
+        empty:  No existen solicitudes de portabilidad
+        table:
+          state: Estado
+          file: Archivo
+          created_at: Fecha de creación
+          destroy: Eliminar
+        button: Solicitar portabilidad
+        states:
+          pending: Pendiente
+          progress: En progreso
+          completed: Completado
+        has_pending: Tienes una solicitud de información pendiente, no puedes hacer otra aún
+        created: Petición de Datos Iniciada!
+    portability_requests:
+      index:
+        title: Solicitudes pendientes
+        destroyed: Solicitud eliminada exitosamente.
+        empty: No existen solicitudes por revisar
+        table:
+          user: Usuario
+          state: Estado
+          created_at: Fecha de creación
+          destroy: Eliminar
+          confirm: Confirmar
+        states:
+          pending: Pendiente
+          progress: En progreso
+          completed: Completado
+    mails:
+      progress:
+        subject: Tu información esta siendo descargada
+      completed:
+        subject: Tu información está disponible
+  will_paginate:
+    previous_label: "<"
+    next_label: ">"
+    page_gap: "…"

data/config/routes.rb

@@ -1,12 +1,22 @@
 PolicyManager::Engine.routes.draw do
 
-  resources :categories do 
+  resources :user_portability_requests, only: [:index, :create, :destroy]
+
+  resources :portability_requests, only: [:index, :destroy] do
+    member do
+      get :confirm
+    end
+  end
+  
+  resources :categories, only: [:show, :index] do 
     resources :terms
   end
-  resources :terms_categories
-  resources :user_terms do 
+
+  resources :user_terms, only: [:show] do 
     collection do 
       get :pending
+      put :accept_multiples
+      get :blocking_terms
     end
     
     member do
@@ -14,7 +24,6 @@ PolicyManager::Engine.routes.draw do
       put :reject 
     end
   end
-  #resources :terms
-  root 'dashboard#index'
-
+  
+  root 'categories#index'
 end

data/db/migrate/20180326193825_create_policy_manager_terms.rb

@@ -3,6 +3,7 @@ class CreatePolicyManagerTerms < ActiveRecord::Migration[5.1]
     create_table :policy_manager_terms do |t|
       t.text :description
       t.string :rule
+      t.string :state
       t.datetime :accepted_at
       t.datetime :rejected_at
       t.timestamps

data/db/migrate/20180410171354_create_policy_manager_portability_requests.rb

@@ -0,0 +1,18 @@
+class CreatePolicyManagerPortabilityRequests < ActiveRecord::Migration[5.1]
+  def change
+    create_table :policy_manager_portability_requests do |t|
+      #t.references :user, foreign_key: true
+      t.integer :user_id, index: true
+      t.string :state
+      t.string :attachment
+      t.string :attachment_file_name
+      t.string :attachment_file_size
+      t.datetime :attachment_content_type
+      t.string :attachment_file_content_type
+
+      t.datetime :expire_at
+
+      t.timestamps
+    end
+  end
+end

data/lib/policy_manager/anonimizer.rb

@@ -0,0 +1,18 @@
+
+        #c.anonimizer do |a|
+        #  c.secret_key = "oeoeo123eoeo"
+        #  c.encryptor = :sha512
+        #  c.rule(on: User, fields: [:email])
+        #end
+
+
+module PolicyManager
+  class Anonimizer
+    attr_accessor :secret_key, :encryptor, :rules 
+                  
+    def initialize(opts={})
+      self.path = opts[:path]
+    end
+
+  end
+end

data/lib/policy_manager/config.rb

@@ -1,19 +1,53 @@
 module PolicyManager
   class Config
 
+    mattr_accessor :exporter, 
+                   :from_email, 
+                   :is_admin_method,
+                   :logout_url, 
+                   :user_language_method,
+                   :scripts
+
     def self.setup
       @@rules = []
+      @@portability_rules = []
+      @@portability_templates = []
+      @@scripts = []
       yield self
       self
     end
     
+    def self.exporter=(opts)
+      @@exporter = Exporter.new(opts)
+    end
+
+    def self.is_admin?(user)
+      @@is_admin_method.call(user)
+    end
+
+    def self.user_language(user)
+      @@user_language_method.call(user) rescue :en
+    end
+
     def self.rules
-      @@rules
+      @@rules ||= []
+    end
+
+    def self.portability_rules
+      @@portability_rules ||= []
     end
 
     def self.add_rule(opts={}, &block)
       @@rules << PolicyManager::Rule.new(opts, &block)
     end
 
+    def self.add_portability_rule(opts={}, &block)
+      @@portability_rules << PolicyManager::PortabilityRule.new(opts, &block)
+    end
+
+    def self.add_script(opts={}, &block)
+      @@scripts << PolicyManager::Script.new(opts, &block)
+    end
+
   end
 end

data/lib/policy_manager/exporter/handler.rb

@@ -0,0 +1,110 @@
+require "fileutils"
+require 'zip'
+
+module PolicyManager
+  class ExporterHandler
+    attr_accessor :resource, :path, :after_zip
+
+    def initialize(opts={})
+      self.path = opts[:path]
+      self.resource = opts[:resource]
+      self.after_zip = opts[:after_zip] if opts[:after_zip]
+    end
+
+    def base_path
+      self.path.join resource.id.to_s
+    end
+
+    def zip_path
+      "#{base_path}-out.zip"
+    end
+
+    def perform
+      FileUtils.mkdir_p(base_path)
+      create_sections
+      generate_zip
+      handle_zip_upload
+      after_zip.call(zip_path, resource)
+      clear!
+    end
+
+    def handle_zip_upload
+      resource
+      .portability_requests
+      .find_by(state: "progress")
+      .update_attributes(file_remote_url: zip_path)
+    end
+
+    def clear!
+      FileUtils.rm_rf(base_path)
+      FileUtils.rm_rf(zip_path)
+    end
+
+    def create_sections
+      PolicyManager::Config.portability_rules.each do |rule|
+        handle_render_for(rule)
+      end
+
+      render_index
+      puts "FOLDER CREATED AT #{base_path}"
+    end
+
+    def handle_render_for(rule)
+      if rule.member
+        render_member(rule)
+      end
+
+      if rule.collection
+        render_collection(rule)
+      end
+    end
+
+    def base_dir
+    end
+
+    def render_member(rule)
+      return unless resource.respond_to?(:portability_member_for)
+      o = resource.portability_member_for(rule)
+      base_dir = self.base_path.join(rule.name)
+      resource_path = base_dir.join("index.html")
+      FileUtils.mkdir_p(base_dir)
+      view = ExporterView.new({member: o}, {build_path: self.base_path, base_path: resource_path, template: rule.template, rule: rule})
+      puts "saving at #{self.path.join rule.name}"
+      view.save(resource_path )
+    end
+
+    def render_collection(rule)
+      return unless resource.respond_to?(:portability_collection_for)
+      o = resource.portability_collection_for(rule ,1)
+      
+      (1..o.total_pages).to_a.each do |i| 
+        o = resource.portability_collection_for(rule,i)
+        page_name = i #== 1 ? "index" : i
+        base_dir  = self.base_path.join(rule.name)
+        base_dir  = base_dir.join(page_name.to_s) unless page_name == 1
+        FileUtils.mkdir_p(base_dir)
+        resource_path = base_dir.join("index.html")
+        view = ExporterView.new({collection: o}, {build_path: self.base_path, base_path: resource_path, template: rule.template, rule: rule})
+        puts "saving at #{self.path.join rule.name}"
+        view.save( resource_path )
+      end
+    end
+
+    def render_index
+      resource_path = self.base_path.join("index.html")
+      template = PolicyManager::Config.exporter.index_template
+      view = ExporterView.new({collection: PolicyManager::Config.portability_rules}, 
+        {build_path: self.base_path, base_path: resource_path, template: template})
+      puts "saving at #{resource_path}"
+      view.save( resource_path )
+    end
+
+    def generate_zip
+      directory_to_zip = base_path.to_s
+      output_file = zip_path.to_s
+      zf = ZipGenerator.new(directory_to_zip, output_file)
+      zf.write()
+    end
+
+  end
+end

data/lib/policy_manager/exporter/paginator_renderer.rb

@@ -0,0 +1,74 @@
+require "will_paginate"
+require 'will_paginate/view_helpers/action_view'
+
+module PolicyManager
+  class PaginatorRenderer < WillPaginate::ActionView::LinkRenderer
+    ELLIPSIS = '&hellip;'
+
+    def to_html
+      list_items = pagination.map do |item|
+        case item
+          when (1.class == Integer ? Integer : Fixnum)
+            page_number(item)
+          else
+            send(item)
+        end
+      end.join(@options[:link_separator])
+
+      list_wrapper = tag :nav, list_items, class: "pagination button-group"
+      tag :nav, list_wrapper
+    end
+
+    def container_attributes
+      super.except(*[:link_options])
+    end
+
+    protected
+
+    def page_number(page)
+      link_options = @options[:link_options] || {}
+
+      if page == current_page
+        tag(:a, page, class: 'btn page-item active', href: '')
+      else
+        tag(:a, page, href: page_path(page), class: 'page-link btn', rel: rel_value(page))
+      end
+    end
+
+    def page_path(page)
+      return "../index.html" if page == 1
+      if @collection.current_page == 1
+        return "./#{page}/index.html" if @collection.current_page < page
+        return "../#{page}/index.html" if @collection.current_page > page
+      else
+        return "../#{page}/index.html"
+      end
+    end
+
+    def previous_or_next_page(page, text, classname)
+      link_options = @options[:link_options] || {}
+      if page
+        link_wrapper = tag(:a, text || page, href: page_path(page), class: "page-link btn" + classname.to_s)
+        # link_wrapper, class: 'page-item '
+      else
+        tag(:a, text, href:'', class: 'page-link btn')
+        # span_wrapper, class: 'page-item disabled'
+      end
+    end
+
+    def gap
+      tag :p, tag(:i, ELLIPSIS, class: 'page-link'), class: 'page-item disabled btn'
+    end
+
+    def previous_page
+      num = @collection.current_page > 1 && @collection.current_page - 1
+      previous_or_next_page num, @options[:previous_label], 'previous btn'
+    end
+
+    def next_page
+      num = @collection.current_page < @collection.total_pages && @collection.current_page + 1
+      previous_or_next_page num, @options[:next_label], 'next btn'
+    end
+
+  end
+end

data/lib/policy_manager/exporter/view.rb

@@ -0,0 +1,108 @@
+require "erb"
+require 'open-uri'
+require "tilt"
+require "will_paginate"
+require 'will_paginate/view_helpers'
+require 'will_paginate/view_helpers/action_view'
+
+
+module PolicyManager
+  class ExporterView
+    
+    include ERB::Util
+    include ActionView::Helpers
+    include WillPaginate::ViewHelpers #if defined?(WillPaginate)
+    include WillPaginate::ActionView #if defined?(WillPaginate)
+    
+    attr_accessor :template, :base_path
+
+    def self.template
+      "Welcome, <%= @name %>"
+    end
+
+    def initialize(vars={}, options={}, date=Time.now)
+      # collection or member, or wathever!?
+      vars.each{|k, v| self.instance_variable_set("@#{k}", v)}
+      @base_path = options[:base_path]
+      @build_path = options[:build_path]
+
+      index_path
+
+      @template = options.fetch(:template, self.class.template)
+
+    end
+
+    def index_path
+      path = @base_path.to_s.gsub(@build_path.to_s, "")
+      len = path.split("/").size 
+      case len
+      when 2
+        @index_path = "./"
+      when 3
+        @index_path = "../"
+      when 4
+        @index_path = "../../"
+      else
+        @index_path = "../../"
+      end
+    end
+
+    def image_tag(remote_image, opts={})
+      begin
+        basename = File.basename(remote_image)
+        id = opts[:id] || SecureRandom.hex(10)
+        composed_name = [id, basename].compact.join("-")
+        path = "#{File.dirname(base_path)}/#{composed_name}"
+        self.save_image(remote_image, path)
+        tag(:img, {src: "./#{id}-#{File.basename(URI(remote_image).path)}" }.merge(opts))
+      rescue => e
+        Bugsnag.notify(e)
+        content_tag(:p, "broken image")
+      end
+    end
+
+    def save_image(remote_image, path)
+      open(URI(path).path, 'wb') do |file|
+        file << open(remote_image).read
+      end
+    end
+
+    def render()
+      #template_layout = Tilt::ERBTemplate.new {PolicyManager::Config.exporter.layout}
+      context = self
+      #template_layout.render { 
+      #  view = Tilt::ERBTemplate.new{handled_template}
+      #  view.render(context)
+      #}
+
+      render_with_layout()      
+    end
+
+    def render_with_layout(context = self)
+      render_layout do
+        ERB.new(handled_template).result(binding)
+      end
+    end
+
+    def render_layout
+      layout = PolicyManager::Config.exporter.layout #File.read('views/layouts/app.html.erb')
+      ERB.new(layout).result(binding)
+    end
+
+
+    def save(file)
+      File.open(file, "w+") do |f|
+        f.write(render)
+      end
+    end
+
+    def handled_template
+      if @template.is_a?(String) 
+        @template
+      elsif @template.is_a?(Pathname)
+        File.open(@template).read
+      end
+    end
+
+  end
+end

data/lib/policy_manager/exporter/zip_generator.rb

@@ -0,0 +1,60 @@
+require 'zip'
+
+# This is a simple example which uses rubyzip to
+# recursively generate a zip file from the contents of
+# a specified directory. The directory itself is not
+# included in the archive, rather just its contents.
+#
+# Usage:
+#   directory_to_zip = "/tmp/input"
+#   output_file = "/tmp/out.zip"
+#   zf = ZipFileGenerator.new(directory_to_zip, output_file)
+#   zf.write()
+
+module PolicyManager
+  class ZipGenerator
+    # Initialize with the directory to zip and the location of the output archive.
+    def initialize(input_dir, output_file)
+      @input_dir = input_dir
+      @output_file = output_file
+    end
+
+    # Zip the input directory.
+    def write
+      entries = Dir.entries(@input_dir) - %w(. ..)
+
+      ::Zip::File.open(@output_file, ::Zip::File::CREATE) do |zipfile|
+        write_entries entries, '', zipfile
+      end
+    end
+
+    private
+
+    # A helper method to make the recursion work.
+    def write_entries(entries, path, zipfile)
+      entries.each do |e|
+        zipfile_path = path == '' ? e : File.join(path, e)
+        disk_file_path = File.join(@input_dir, zipfile_path)
+        puts "Deflating #{disk_file_path}"
+
+        if File.directory? disk_file_path
+          recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+        else
+          put_into_archive(disk_file_path, zipfile, zipfile_path)
+        end
+      end
+    end
+
+    def recursively_deflate_directory(disk_file_path, zipfile, zipfile_path)
+      zipfile.mkdir zipfile_path
+      subdir = Dir.entries(disk_file_path) - %w(. ..)
+      write_entries subdir, zipfile_path, zipfile
+    end
+
+    def put_into_archive(disk_file_path, zipfile, zipfile_path)
+      zipfile.get_output_stream(zipfile_path) do |f|
+        f.write(File.open(disk_file_path, 'rb').read)
+      end
+    end
+  end
+end

data/lib/policy_manager/exporter.rb

@@ -0,0 +1,75 @@
+require "fileutils"
+
+module PolicyManager
+  class Exporter
+    attr_accessor :path, 
+                  :resource, 
+                  :index_template, 
+                  :layout, 
+                  :after_zip, 
+                  :mail_helpers, 
+                  :attachment_path,
+                  :attachment_storage, 
+                  :expiration_link,
+                  :mailer_templates,
+                  :mailer
+
+    def initialize(opts={})
+      self.path = opts[:path]
+      self.resource = opts[:resource] #.call if opts[:resource].is_a?(Proc)
+      self.index_template = opts[:index_template]
+      self.layout = opts[:layout]
+      self.after_zip = opts[:after_zip]
+      self.mail_helpers = opts[:mail_helpers]
+      self.attachment_path = opts[:attachment_path]
+      self.attachment_storage = opts[:attachment_storage]
+      self.expiration_link = opts[:expiration_link]
+      self.mailer_templates = opts[:mailer_templates]
+    end
+
+    def perform(resource)
+      e = ExporterHandler.new(resource: resource, path: path, after_zip: after_zip)
+      e.perform
+    end
+
+    def clear!(resource)
+      e = ExporterHandler.new(resource: resource, path: path)
+      e.clear!
+    end
+
+    def index_template
+      handled_template(@index_template) || default_index_template
+    end
+
+    def layout
+      handled_template(@layout) || '<body> eeeee <%= yield %> eeee</body>'
+    end
+
+    def mail_helpers
+      @mail_helpers ||= []
+    end
+
+    def expiration_link
+      @expiration_link ||= 60
+    end
+
+    def handled_template(template)
+      return if template.blank?
+      if template.is_a?(String) 
+        template
+      elsif template.is_a?(Pathname)
+        File.open(template).read
+      end
+    end
+
+    def default_index_template
+      '<h1>links</h1>
+      <ul>
+        <% @collection.each do |rule| %>
+          <li><%= link_to rule.name, "./#{rule.name}" %></li>
+        <% end %>
+      </ul>'
+    end
+
+  end
+end

data/lib/policy_manager/portability_rule.rb

@@ -0,0 +1,15 @@
+module PolicyManager
+  class PortabilityRule
+    attr_accessor :name, :methods, :formats, :per, :collection, :member, :template
+
+    def initialize(opts={})
+      self.collection = opts[:collection]
+      self.member = opts[:member]
+      self.per = opts[:per]
+      self.name = opts[:name]
+      self.formats = opts[:formats]
+      self.template = opts[:template]
+    end
+
+  end
+end