linked_rails 0.0.3 → 0.0.4.pre.g1faca9643

data/lib/generators/linked_rails/install/templates/app_menu_list.rb

@@ -8,29 +8,58 @@ class AppMenuList < ApplicationMenuList
            menus: -> { user_menu_items }
 
   def iri_template
-    @iri_template ||= URITemplate.new('/menus{#fragment}')
+    @iri_template ||= LinkedRails::URITemplate.new('/menus{#fragment}')
   end
 
   private
 
-  def navigation_links
-    items = []
-    items << menu_item(
+  def home_menu_item
+    menu_item(
       :home,
       label: I18n.t('menus.home'),
       href: LinkedRails.iri,
       image: 'fa-home'
     )
-    items
+  end
+
+  def navigation_links
+    [home_menu_item]
   end
 
   def user_menu_items
     return [] if user_context.guest?
 
-    [user_menu_sign_out_item]
+    [
+      otp_menu_item,
+      sign_out_menu_item
+    ]
+  end
+
+  def otp_menu_item
+    if user_context.otp_active?
+      delete_otp_menu_item
+    else
+      add_otp_menu_item
+    end
+  end
+
+  def delete_otp_menu_item
+    menu_item(
+      :otp,
+      label: I18n.t('menus.delete_otp'),
+      href: LinkedRails.iri(path: 'u/otp_secret/delete')
+    )
+  end
+
+  def add_otp_menu_item
+    menu_item(
+      :otp,
+      label: I18n.t('menus.add_otp'),
+      href: LinkedRails.iri(path: 'u/otp_secret/new')
+    )
   end
 
-  def user_menu_sign_out_item
+  def sign_out_menu_item
     menu_item(
       :signout,
       action: Vocab.libro['actions/logout'],

data/lib/generators/linked_rails/install/templates/application_menu_list.rb

@@ -1,3 +1,42 @@
 # frozen_string_literal: true
 
-class ApplicationMenuList < LinkedRails::Menus::List; end
+class ApplicationMenuList < LinkedRails::Menus::List
+  include LinkedRails::Helpers::OntolaActionsHelper
+
+  private
+
+  def copy_menu_item(url)
+    menu_item(
+      :copy,
+      action: ontola_copy_action(url),
+      item_type: 'copy',
+      image: 'fa-clipboard',
+      href: url
+    )
+  end
+
+  def delete_menu_item(resource)
+    iri = resource.iri.dup
+    iri.path += '/delete'
+
+    menu_item(
+      :destroy,
+      action: ontola_dialog_action(iri),
+      href: iri,
+      image: 'fa-close',
+      policy: :destroy?
+    )
+  end
+
+  def edit_menu_item(resource)
+    iri = resource.iri.dup
+    iri.path += '/edit'
+
+    menu_item(
+      :edit,
+      image: 'fa-edit',
+      href: iri,
+      policy: :update?
+    )
+  end
+end

data/lib/generators/linked_rails/install/templates/initializer.rb

@@ -2,8 +2,7 @@
 
 require_relative '../../lib/vocab'
 
-LinkedRails.host = 'example.com'
+LinkedRails.host = raise('Enter your host. Use an ENV var if you have multiple environments')
 LinkedRails.scheme = :https
-LinkedRails.app_vocab = Vocab.example
 
 LinkedRails::Renderers.register!

data/lib/generators/linked_rails/install/templates/locales.yml

@@ -1,4 +1,18 @@
 en:
+  actions:
+    default:
+      create:
+        label: "New %{type}"
+        success: 'Created successfully'
+      destroy:
+        label: "Delete"
+        description: "Are you sure you want to delete this %{type}?"
+        success: 'Destroyed successfully'
+      update:
+        label: "Edit"
+        success: 'Updated successfully'
+  errors:
+    access_denied: "You're not authorized for this action. (%{action})"
   linked_rails:
     status:
       400: "Error in request"
@@ -10,3 +24,5 @@ en:
   menus:
     home: "Home"
     sign_out: "Sign out"
+    add_otp: "Enable 2fa"
+    delete_otp: "Remove 2fa"

data/lib/generators/linked_rails/install/templates/rdf_serializers_initializer.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 RDF::Serializers.configure do |config|
-  config.default_graph = Vocab.ll[:supplant]
+  config.default_graph = Vocab.ld[:supplant]
 end

data/lib/generators/linked_rails/install/templates/vocab.rb

@@ -2,4 +2,5 @@
 
 class Vocab < LinkedRails::Vocab
   register(:example, 'https://example.com/my_vocab#')
+  app_vocabulary :example
 end

data/lib/generators/linked_rails/install/templates/vocab.yml

@@ -1,10 +1,10 @@
 en:
   foaf:
     name:
-      label: "Naam"
+      label: "Name"
   ontola:
     password:
-      label: "Wachtwoord"
+      label: "Password"
     quickActions:
       label: "Actions"
   rdfv:

data/lib/generators/linked_rails/model/model_generator.rb

@@ -17,7 +17,6 @@ module LinkedRails
     end
 
     def copy_files # rubocop:disable Metrics/AbcSize
-      template 'action_list.rb', File.join('app', 'actions', class_path, "#{file_name}_action_list.rb")
       template 'controller.rb', File.join('app', 'controllers', class_path, "#{plural_file_name}_controller.rb")
       template 'form.rb', File.join('app', 'forms', class_path, "#{file_name}_form.rb")
       template 'menu_list.rb', File.join('app', 'menus', class_path, "#{file_name}_menu_list.rb")

data/lib/generators/linked_rails/model/templates/controller.rb.tt

@@ -2,6 +2,10 @@
 
 <% module_namespacing do -%>
 class <%= controller_class_name %>Controller < ApplicationController
-    active_response :show, :index
+  active_response :show, :index
+
+  has_collection_create_action
+  has_resource_update_action
+  has_resource_destroy_action
 end
 <% end -%>

data/lib/generators/linked_rails/model/templates/form.rb.tt

@@ -2,5 +2,8 @@
 
 <% module_namespacing do -%>
 class <%= class_name %>Form < ApplicationForm
+<% attributes.reject(&:reference?).each do |attribute| -%>
+  field :<%= attribute.name %>
+<% end -%>
 end
 <% end -%>

data/lib/generators/linked_rails/model/templates/menu_list.rb.tt

@@ -2,5 +2,20 @@
 
 <% module_namespacing do -%>
 class <%= class_name %>MenuList < ApplicationMenuList
+  has_menu(
+    :actions,
+    image: 'fa-ellipsis-v',
+    menus: -> { action_menu_items }
+  )
+
+  private
+
+  def action_menu_items
+    [
+      edit_menu_item(resource),
+      delete_menu_item(resource),
+      copy_menu_item(resource.iri),
+    ]
+  end
 end
 <% end -%>

data/lib/generators/linked_rails/model/templates/policy.rb.tt

@@ -2,5 +2,18 @@
 
 <% module_namespacing do -%>
 class <%= class_name %>Policy < ApplicationPolicy
+  permit_attributes %i[<%= attributes.reject(&:reference?).map { |attribute| attribute.name }.join(' ') %>]
+
+  def create?
+    false
+  end
+
+  def update?
+    false
+  end
+
+  def destroy?
+    false
+  end
 end
 <% end -%>

data/lib/generators/linked_rails/model/templates/serializer.rb.tt

@@ -3,7 +3,11 @@
 <% module_namespacing do -%>
 class <%= class_name %>Serializer < ApplicationSerializer
 <% attributes.each do |attribute| -%>
-    attribute :<%= attribute.name %>, predicate: LinkedRails.app_vocab[:<%= attribute.name %>]
+<% if attribute.reference? -%>
+  has_one :<%= attribute.name %>, predicate: Vocab.app[:<%= attribute.name.camelize(:lower) %>]
+<% else -%>
+  attribute :<%= attribute.name %>, predicate: Vocab.app[:<%= attribute.name.camelize(:lower) %>]
+<% end -%>
 <% end -%>
 end
 <% end -%>

data/lib/linked_rails/active_response/controller/collections.rb

@@ -9,7 +9,7 @@ module LinkedRails
         def index_association; end
 
         def index_includes
-          requested_resource.preview_includes
+          requested_resource!.try(:preview_includes)
         end
 
         def index_iri

data/lib/linked_rails/active_response/controller/crud_defaults.rb

@@ -10,8 +10,8 @@ module LinkedRails
           current_resource!
             .class
             .try(:reflect_on_all_associations)
-            .select(&:collection?)
-            .each { |association| current_resource!.association(association.name).reset }
+            &.select(&:collection?)
+            &.each { |association| current_resource!.association(association.name).reset }
         end
 
         def create_execute
@@ -50,7 +50,7 @@ module LinkedRails
         def requested_resource
           @requested_resource ||= controller_class.try(
             :requested_resource,
-            LinkedRails.iri_mapper.route_params_to_opts(params.dup),
+            LinkedRails.iri_mapper.route_params_to_opts(params.dup, request.original_url),
             user_context
           )
         end
@@ -80,7 +80,7 @@ module LinkedRails
         end
 
         def update_meta
-          changes_triples + changed_relations_triples
+          changes_triples(current_resource) + changed_relations_triples(current_resource)
         end
 
         def user_context

data/lib/linked_rails/active_response/controller/params.rb

@@ -11,17 +11,13 @@ module LinkedRails
         end
 
         def params_parser
-          @params_parser ||= LinkedRails::ParamsParser.new(params)
-        end
-
-        def parsed_filter_params
-          filters = params_parser.filter_params
-
-          ActionController::Parameters.new(controller_class.try(:attributes_from_filters, filters) || {})
+          @params_parser ||= LinkedRails::ParamsParser.new(params: params, user_context: user_context)
         end
 
         def permit_filter_params
-          @permit_filter_params ||= parsed_filter_params.permit(*permit_param_keys)
+          @permit_filter_params ||=
+            policy(requested_resource || new_resource)
+              .permitted_attributes_from_filters(params_parser.filter_params)
         end
 
         def permit_params
@@ -37,11 +33,15 @@ module LinkedRails
         end
 
         def permit_params_with_filters
-          permit_filter_params.merge(permit_params.to_h)
+          permitted = permit_filter_params.merge(permit_params.to_h)
+          permitted[:singular_resource] = true if params[:singular_route].to_s == 'true'
+          permitted
         end
 
         def resource_params
-          return ActionController::Parameters.new if !params.key?(permit_param_key) && allow_empty_params?
+          empty_params = !params.key?(permit_param_key) || params[permit_param_key] == {}
+
+          return ActionController::Parameters.new if empty_params && allow_empty_params?
 
           params.require(permit_param_key)
         end

data/lib/linked_rails/active_response/controller.rb

@@ -8,30 +8,20 @@ require_relative 'controller/params'
 
 module LinkedRails
   module Controller
-    include Pundit
+    include Pundit::Authorization
     include LinkedRails::ActiveResponse::Controller::Collections
     include LinkedRails::ActiveResponse::Controller::CrudDefaults
     include LinkedRails::ActiveResponse::Controller::Params
 
-    def _render_with_renderer_json(record, options)
-      self.content_type = Mime[:json]
-
-      return record if record.is_a?(String)
-      return record.to_json if record.is_a?(Hash)
-
-      serializer_opts = RDF::Serializers::Renderers.transform_opts(
-        options,
-        serializer_params
-      )
-
-      serializer = RDF::Serializers.serializer_for(record)&.new(record, serializer_opts)
-      return record.to_json unless serializer
-
-      Oj.dump(serializer.serializable_hash, mode: :compat)
+    def success_message_translation_key
+      "actions.#{Translate.translation_key(controller_class)}.#{action_name}.success"
     end
 
-    def serializer_params
-      {}
+    def success_message_translation_opts
+      {
+        default: [:"actions.default.#{action_name}.success", ''],
+        type: I18n.t("#{controller_class.model_name.collection}.type").capitalize
+      }
     end
   end
 end

data/lib/linked_rails/active_response/responders/rdf.rb

@@ -37,7 +37,7 @@ module LinkedRails
           response_headers(opts)
           controller.respond_with_resource(
             resource: nil,
-            meta: error_meta(opts[:resource]),
+            meta: error_meta(opts[:resource], opts[:errors] || {}),
             status: :unprocessable_entity
           )
         end
@@ -47,15 +47,22 @@ module LinkedRails
           controller.respond_with_resource(opts)
         end
 
-        def redirect(**opts) # rubocop:disable Metrics/AbcSize
+        def redirect(**opts) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           return super if controller.request.head?
 
+          opts[:status] ||= 200
+
           response_headers(opts)
           add_exec_action_header(
             controller.response.headers,
             ontola_redirect_action(opts[:location], reload: opts[:reload])
           )
-          controller.head 200, content_type: content_type, location: opts[:location]
+          if opts[:meta].blank? || head_request?
+            controller.head(opts[:status], location: opts[:location], content_type: content_type)
+          else
+            opts[format] = []
+            controller.render opts
+          end
         end
 
         def resource(**opts) # rubocop:disable Metrics/AbcSize
@@ -89,10 +96,10 @@ module LinkedRails
           ]
         end
 
-        def error_statements(iri, resource)
+        def error_statements(iri, resource, resource_errors)
           index = 0
-          resource.errors.messages.map do |key, values|
-            predicate = resource.class.predicate_for_key(key.to_s.split('.').first)
+          resource_errors.map do |key, values|
+            predicate = resource&.class&.predicate_for_key(key.to_s.split('.').first)
             if predicate
               error_statements_for(iri, predicate, values)
             else
@@ -106,16 +113,18 @@ module LinkedRails
           values.map { |value| [iri, predicate, value.sub(/\S/, &:upcase)] }
         end
 
-        def error_meta(resource)
+        def error_meta(resource, custom_errors)
           form_iri = controller.request.headers['Request-Referrer']
-          return [] unless form_iri && resource.respond_to?(:errors)
+          resource_errors = (resource.try(:errors)&.messages || {}).merge(custom_errors)
+
+          return [] unless form_iri && resource_errors.present?
 
           error_object = ::RDF::Node.new
           [
             error_mapping(form_iri, error_object),
             error_type(error_object),
             error_status(error_object)
-          ] + error_statements(error_object, resource)
+          ] + error_statements(error_object, resource, resource_errors)
         end
 
         def error_type(error_object)
@@ -149,7 +158,7 @@ module LinkedRails
           error_statements_for(
             iri,
             ::RDF["_#{index}"],
-            values.map { |value| resource.errors.full_message(key, value) }
+            values.map { |value| resource&.errors&.full_message(key, value) || value }
           )
         end
       end

data/lib/linked_rails/callable_variable.rb

@@ -5,7 +5,7 @@ module LinkedRails
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def callable_variable(method, opts = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def callable_variable(method, **opts) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
         variable ||= opts[:variable] || method
         default ||= opts[:default]
 

data/lib/linked_rails/collection_params_parser.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class CollectionParamsParser
+    attr_reader :params, :user_context
+
+    def initialize(params)
+      @user_context = params[:user_context]
+      @params = params.is_a?(Hash) ? ActionController::Parameters.new(params) : params
+    end
+
+    def collection_params
+      return @collection_params if instance_variable_defined?(:@collection_params)
+
+      values = permit_params(:display, :page_size, :table_type, :title, :type)
+
+      filter = filter_params
+      values[:filter] = filter if filter
+
+      sort = sorting_params
+      values[:sort] = sort if sort
+
+      values[:user_context] = user_context if user_context
+
+      @collection_params = values
+    end
+
+    def collection_view_params
+      return @collection_view_params if instance_variable_defined?(:@collection_view_params)
+
+      values = permit_params(:page)
+
+      before = before_params
+      values[:before] = before if before
+
+      @collection_view_params = values
+    end
+
+    def filter_params # rubocop:disable Metrics/AbcSize
+      return @filter_params if instance_variable_defined?(:@filter_params)
+
+      values = permit_params(filter: [])[:filter] || permit_params(filter: {})[:filter]
+      return @filter_params = values if values.is_a?(Hash)
+      return @filter_params = {} if values.blank?
+
+      @filter_params = values.each_with_object({}) do |f, hash|
+        values = f.split('=')
+        key = RDF::URI(CGI.unescape(values.first))
+        hash[key] ||= []
+        hash[key] << CGI.unescape(values.second)
+      end
+    end
+
+    private
+
+    def before_params
+      return @before_params if instance_variable_defined?(:@before_params)
+
+      values = permit_params(before: [])[:before]
+      return @before_params = nil if values.blank?
+
+      @before_params = values.map do |f|
+        key, value = f.split('=')
+        {key: RDF::URI(CGI.unescape(key)), value: value}
+      end
+    end
+
+    def parse_filter_value(value)
+      return value if value.is_a?(Hash)
+
+      key, value = value.split('=')
+      {key: RDF::URI(CGI.unescape(key)), direction: value}
+    end
+
+    def permit_params(*keys)
+      params
+        .permit(*keys)
+        .to_h
+        .with_indifferent_access
+    end
+
+    def sorting_params
+      return @sorting_params if instance_variable_defined?(:@sorting_params)
+
+      values = permit_params(sort: [])[:sort]
+      return @sorting_params = nil if values.blank?
+
+      @sorting_params = values.map do |f|
+        parse_filter_value(f)
+      end
+    end
+  end
+end