tiun 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2fbc413e898484528e778a515a8fb4c6100645480aaa080635d8fcc26a46d4ab
-  data.tar.gz: a499c45cc16511a8992d495817d7d0571274fb816e4d334a0e80b97c6e9221cb
+  metadata.gz: 21e5c97ff2ba65ab332a7fd9e268dba1b75f9a3bc5047158d2f13e83645fc493
+  data.tar.gz: bbbd5267a33c1191ff2196748e0c95f0f9847713b76dcf7555e02ab3f497accb
 SHA512:
-  metadata.gz: 7918ed70518520fac363a1035d79659e9b3c0e56e72fb2d34b540eb145d230dd54e68f0a8a6bc8ab6918dfcd2b8daef438230fbc5b5bf885535abef1a6905985
-  data.tar.gz: 4fc68d05fe8bbe4cfe556e88a6b9768d61d456bce85d472225e16d0a80f96bcd9ab474938bf1166f568bf33c86963c67c017f6c20657b3f15653e7d15c26fdee
+  metadata.gz: 0ec044da0a8a1821a9732eb305b864626c301f1fe8c87eea1a6e7e8af55c138acee0cffee09690545241c90938cdc430e0c74a5baeb817c0db0ebf7ab84a1dfd
+  data.tar.gz: 64060e2051a3b0d280719ce69f3f006400686753a02e28f093e510b91403690486b6e875dfc384628e234ced08549b0b096d36f241c68423510044448b06535e

data/Gemfile

@@ -1,6 +1,7 @@
 source "https://rubygems.org"
 
 git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+git_source(:codeberg) {|repo_name| "https://codeberg.org/#{repo_name}" }
 #
 # Specify your gem's dependencies in tiun.gemspec
 gemspec

data/README.md

@@ -32,7 +32,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/tiun. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://codeberg.org/znamenica/tiun. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -40,4 +40,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Tiun project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/tiun/blob/master/CODE_OF_CONDUCT.md).
+Everyone interacting in the Tiun project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://codeberg.org/znamenica/tiun/blob/master/CODE_OF_CONDUCT.md).

data/lib/config/locale/ru.yml

@@ -0,0 +1,8 @@
+---
+ru:
+   tiun:
+      auth:
+         controller:
+            invalidtokenerror: "Неверный токен"
+      session:
+         updated: "Токен дейсвителен, а сессия обновлена"

data/lib/tiun/auth/controller.rb

@@ -0,0 +1,228 @@
+require 'active_support'
+require 'tiun/auth'
+
+module Tiun::Auth::Controller
+   class NoTokenError < StandardError; end
+   class InvalidTokenError < StandardError; end
+
+   extend ActiveSupport::Concern
+
+   included do
+      include Tiun::Auth
+
+      before_action :set_languages
+      before_action :authenticate
+      before_action :fetch_token, only: %i(update show destroy)
+      before_action :authorize!, only: %i(create update show destroy)
+      after_action :obsolete_token, only: %i(update show destroy)
+      after_action :session_update, only: %i(create update show destroy)
+      after_action :drop_auth, only: %i(destroy)
+
+      rescue_from Exception, with: :exception
+      rescue_from ActiveRecord::RecordNotFound, with: :unauthenticated
+      rescue_from Tiun::Model::Account::InvalidPasswordError, with: :unauthenticated
+      rescue_from NoTokenError, InvalidTokenError, with: :invalid_token
+   end
+
+   # POST /session.json
+   def create
+      @session = @current_user.generate_session
+
+      respond_to do |format|
+         format.html { redirect_to :root, notice: I18n.t("tiun.session.created") }
+         format.json { render json: session_data }
+      end
+   end
+
+   # PUT /session.json
+   def update
+      @session = @current_user.update_session(@token)
+
+      respond_to do |format|
+         format.html { redirect_to :root, notice: I18n.t("tiun.session.updated") }
+         format.json { render json: session_data }
+      end
+   end
+
+   # GET /session.json
+   def show
+      @session = @current_user.current_session(@token)
+
+      respond_to do |format|
+         format.html { redirect_to :root }
+         format.json { render json: session_data }
+      end
+   end
+
+   # DELETE /session.json
+   def destroy
+      @session = @current_user.destroy_session(@token)
+
+      respond_to do |format|
+         format.html { redirect_to :root, notice: I18n.t("tiun.session.deleted") }
+         format.json { render json: serialize_collection([]) }
+      end
+   end
+
+   protected
+
+   def drop_auth
+      session.delete("user")
+   end
+
+   def model_name
+      @_model_name ||= 'Token'
+   end
+
+   def param_name
+      @_param_name ||= model_name.tableize.singularize
+   end
+
+   def user_model
+      @_user_model ||= User
+   end
+
+   def account_model_name
+      @account_model_name ||= "Account"
+   end
+
+   def account_model
+     @account_model ||= account_model_name.constantize
+   end
+
+   def unauthenticated e
+      render_code 401
+   end
+
+   def render_code code
+      args = params.permit(*permitted_filter).to_h
+      res = { status: code, json: { args: args }}
+
+      args.present? ? render(**res) : head(code)
+   end
+
+   def invalid_token e
+      render_code 404
+   end
+
+   def exception e
+      error = "[#{e.class}]{exception}> #{e.message} \n\t #{e.backtrace.join("\n\t")}"
+      args = params.permit(*permitted_filter).to_h
+      render json: { args: args, error: error }, status: 500
+   end
+
+   def locales
+      I18n.available_locales
+   end
+
+   def supplement_names
+      [:created_at, :updated_at]
+   end
+
+   def context
+      @_context ||= {
+         except: supplement_names,
+         locales: locales,
+         languages: @languages,
+      }
+   end
+
+   def set_languages
+      # NOTE the default values
+      @languages ||= %i(ру)
+   end
+
+   def default_arg
+      self.class.instance_variable_get(:@default_arg)&.[](action_name) || "id"
+   rescue NameError
+      "id"
+   end
+
+   def fetch_token
+      if params[:type] && params[:token]
+         raise NoTokenError unless token = params[:token]
+         raise InvalidTokenError.new(auth) unless type = params[:type]
+      else
+         raise NoTokenError unless auth = request.headers["Authorization"]
+         raise InvalidTokenError.new(auth) unless /(?<type>[\w]+) (?<token>.*)/ =~ auth
+         raise InvalidTokenError.new(auth) unless require_token_table.include?(type)
+      end
+
+      attrs = { code: token, type: "Token::#{type[0..7].camelcase}", obsoleted_at: nil }
+      @token = Token.where(attrs).first || raise(InvalidTokenError)
+   end
+
+   def require_token_table
+      {
+        "update" => ["Validate", "Refresh"],
+        "show" => ["Session"],
+        "destroy" => ["Session", "Refresh"],
+      }[action_name] || []
+   end
+
+   def parms
+      @parms ||= params[account_model_name.downcase] || params
+   end
+
+   def account
+      arg_name = default_arg
+
+      @account ||=
+         if !arg_name
+            account_model.find(params[account_model.primary_key])
+         elsif account_model.respond_to?("by_credentials_or_id")
+            account_model.by_credentials_or_id(parms[arg_name]).first
+         else
+            account_model.where({ arg_name => parms[arg_name] }).first
+         end# || raise(ActiveRecord::RecordNotFound)
+   end
+
+   def authenticate
+      @current_user ||=
+         if session["user"]
+            User.find_by_id(session["user"]["id"])
+         else
+            account&.authenticated_user!(parms[:password])
+         end
+   rescue
+   end
+
+   def authorize!
+      @current_user ||= @token.tokenable.is_a?(user_model) ? @token.tokenable : @token.tokenable.user
+   end
+
+   def _permitted_filter
+      @_permitted_filter ||= {}
+   end
+
+   def permitted_filter
+      _permitted_filter[action_name] ||=
+         if c = self.class.instance_variable_get(:@context)[action_name]
+            (c.args || []).reject { |x| x.hidden }.map {|x| x.name }
+         else
+            [model.primary_key]
+         end
+   end
+
+   def obsolete_token
+      @token.update_attribute(:obsoleted_at, Time.zone.now)
+   end
+
+   def session_update
+      session.update("user" => session_data)
+   rescue ActiveRecord::RecordNotFound
+      session.update("user" => nil)
+   end
+
+   def current_user
+      @current_user ||= authenticate
+   end
+
+   def session_data
+      #@current_user&.jsonize(only: %w(id last_login_at last_active_at accounts refresh_token session_token))
+
+      @session_data ||= current_user_data.merge(serialize_collection(@session))
+   end
+end
+
+Auth::Controller = Tiun::Auth::Controller

data/lib/tiun/auth.rb

@@ -0,0 +1,85 @@
+module Tiun::Auth
+   extend ActiveSupport::Concern
+
+   included do
+      before_action :authenticate_user
+   end
+
+   # TODO add automatic with list
+   def current_user
+      @current_user ||=
+        #if session["user"] && user = User.where(id: session["user"]["id"]).first
+         if session["user"] && user = User.with_user_names(auth_context).with_descriptions(auth_context).with_accounts(auth_context).where(id: session["user"]["id"]).first
+            session_data = serialize_collection(user.update_session(session["user"]["refresh_token"]), auth_context)
+            session.update("user" => session["user"].merge(session_data))
+
+            user
+         end
+   rescue Tiun::Model::Auth::InvalidTokenError
+      session.delete('user')
+
+      nil
+   end
+
+   def authenticate_user
+      current_user
+   end
+
+   def model_name
+      @_model_name ||= self.class.to_s.gsub(/.*::/, "").gsub("Controller", "").singularize
+   end
+
+   def model
+      @_model ||= model_name.constantize
+   rescue NameError
+      User
+   end
+
+   def get_properties for_object = nil
+      @get_properties ||=
+         if k = self.class.instance_variable_get(:@context)&.[](action_name)&.kind
+            Tiun.type_attributes_for(k)
+         else
+            case for_object
+            when ActiveRecord::Reflection, ActiveRecord::Associations, ActiveRecord::Scoping, ActiveRecord::Base
+               for_object.model
+            when Array
+               for_object.find { |x| x.respond_to?(:attribute_types) } ||
+                  for_object.find { |x| x.class.respond_to?(:attribute_types) }.class
+            when Hash
+               for_object.values.find { |x| x.respond_to?(:attribute_types) } ||
+                  for_object.values.find { |x| x.class.respond_to?(:attribute_types) }.class
+            when NilClass
+               model
+            else
+               for_object
+            end.attribute_types.keys
+         end
+   end
+
+   def auth_context
+      @auth_context ||= { except: supplement_names, locales: locales }
+   end
+
+   def context
+      @context ||= { except: supplement_names, locales: locales }
+   end
+
+   def locales
+      @locales ||= [I18n.locale]
+   end
+
+   def supplement_names
+      %i(created_at updated_at tsv)
+   end
+
+   def serialize_collection collection, context = self.context
+      collection.as_json(context.merge(only: get_properties(collection)))
+   end
+
+   def serialize object, context = self.context
+      object.as_json(context.merge(only: get_properties(object)))
+   end
+end
+
+Auth = Tiun::Auth

data/lib/tiun/autocontroller.rb.erb

@@ -1,9 +1,11 @@
 require 'tiun/base'
 require 'tiun/core_helper'
 
-class ::<%= object_name %><%= object_in ? nil : " < " + base_controller.to_s %>
+<% base = object_in ? nil : " < #{base_controller}" %>
+
+class ::<%= object_name %><%= base %>
    include ::Tiun::CoreHelper
-   include ::Tiun::Base
+   include ::<%= template_controller_for(context) %>
 
    <% if action_names = action_names_for(context) %>
       @context = (@context || {}).merge(YAML.load("<%= action_names.to_yaml.gsub('"', '\"') %>", permitted_classes: [OpenStruct, Symbol]))

data/lib/tiun/automodel.rb.erb

@@ -1,6 +1,9 @@
 require 'tiun/model'
 
-class ::<%= object_name %><%= object_in ? nil : " < " + base_model.to_s %>
+class ::<%= object_name %><%= object_in || !table_exist?(object_name) ? nil : " < " + base_model(object_name).to_s %>
+   <% unless table_exist?(object_name) %>
+      include <%= base_model(object_name).to_s %>
+   <% end %>
    extend ::Tiun::Model
 
    tiun

data/lib/tiun/base.rb

@@ -2,12 +2,14 @@ require 'active_support'
 
 module Tiun::Base
    class OutOfRangeError < StandardError; end
+   class InvalidParamNameError < StandardError; end
 
    extend ActiveSupport::Concern
 
    included do
-      attr_reader :objects, :object
+      include Tiun::Auth
 
+      attr_reader :object
 
       #attr_accessor :params
       #define_callbacks :subscribe
@@ -21,16 +23,18 @@ module Tiun::Base
 #         I18n.with_locale(I18n.locale.to_s, &block)
 #      include Pundit
 
-#      before_action :authenticate_user!
+      before_action :set_languages, if: ->{ respond_to?(:set_languages) }
+      before_action :authenticate_user
 #      before_action :set_tokens, only: %i(index)
 #      before_action :set_page, only: %i(index)
 #      before_action :set_locales
       before_action :new_object, only: %i(create)
       before_action :fetch_object, only: %i(show update destroy)
       before_action :fetch_objects, only: %i(index)
+      before_action :fetch_ac_objects, only: %i(ac)
       before_action :parse_range, only: %i(index ac)
       after_action :return_range, only: %i(index ac)
-#      before_action :authorize!
+      before_action :authorize!
 
       rescue_from Exception, with: :exception
       rescue_from ActionView::MissingTemplate, with: :missing_template
@@ -57,7 +61,7 @@ module Tiun::Base
       end
    end
 
-   # POST /<objects>/create.json
+   # POST /<objects>.json
    def create
       object.save!
 
@@ -93,13 +97,14 @@ module Tiun::Base
 
    # DELETE /<objects>/:id.json
    def destroy
+      answer = serialize(object)
       object.destroy
 
       respond_to do |format|
          format.html
-         format.json { render json: serialize(object) }
+         format.json { render json: answer }
          format.jsonp { head :ok }
-         format.any { render json: serialize(object), content_type: 'application/json' }
+         format.any { render json: answer, content_type: 'application/json' }
       end
    rescue Exception
      binding.pry
@@ -107,8 +112,6 @@ module Tiun::Base
 
    # GET /<objects>/ac.json
    def ac
-      @objects = apply_scopes(model)
-
       respond_to do |format|
          format.json {
             render json: {
@@ -131,18 +134,10 @@ module Tiun::Base
       total == 0 ? 204 : total > range.end + 1 ? 206 : 200
    end
 
-   def model_name
-      @_model_name ||= self.class.to_s.gsub(/.*::/, "").gsub("Controller", "").singularize
-   end
-
    def param_name
       @_param_name ||= model_name.tableize.singularize
    end
 
-   def model
-      @_model ||= model_name.constantize
-   end
-
 #   def serializer
 #      @serializer ||= "#{model_name}Serializer".constantize
 #   end
@@ -159,10 +154,6 @@ module Tiun::Base
 #      list_serializer.new(model: model)
 #   end
 #
-   def apply_scopes model
-      model
-   end
-
 #   def policy_name
 #      @policy_name ||= Object.const_get(model.name + "Policy")
 #   rescue NameError
@@ -178,56 +169,66 @@ module Tiun::Base
    end
 
    def unprocessable_entity e
-      errors = @object && @object.errors.any? && @object.errors || e.to_s
+      errors = @object && @object.errors.any? && @object.errors.to_a || [e.to_s]
       args = params.permit(*permitted_filter).to_h
       render json: { args: args, error: errors }, status: :unprocessable_entity
    end
 
    def parameter_missing e
-      error = "[#{e.class}]> #{e.message} \n\t #{e.backtrace.join("\n\t")}"
+      errors = ["[#{e.class}]{parameter_missing}> #{e.message} \n\t #{e.backtrace.join("\n\t")}"]
       args = params.permit(*permitted_filter).to_h
-      render json: { args: args, error: error }, status: 500
+      render json: { args: args, error: errors }, status: 500
    end
 
    def missing_template e
-      error = "[#{e.class}]> #{e.message} \n\t #{e.backtrace.join("\n\t")}"
+      errors = ["[#{e.class}]{missing_template}> #{e.message} \n\t #{e.backtrace.join("\n\t")}"]
       args = params.permit(*permitted_filter).to_h
-      render json: { args: args, error: error }, status: 500
+      render json: { args: args, error: errors }, status: 500
    end
 
    def exception e
-      error = "[#{e.class}]> #{e.message} \n\t #{e.backtrace.join("\n\t")}"
+      errors = ["[#{e.class}]{exception}> #{e.message} \n\t #{e.backtrace.join("\n\t")}"]
       args = params.permit(*permitted_filter).to_h
-      render json: { args: args, error: error }, status: 500
+      render json: { args: args, error: errors }, status: 500
    end
 
    def ac_limit
       500
    end
 
-   def context
-      @_context ||= { except: supplement_names, locales: locales }
-   end
-
    def ac_context
       @_ac_context ||= { only: %i(key value) }
    end
 
-   def permitted_filter
+   def tiun_context
+      self.class.instance_variable_get(:@context) || {}
+   end
+
+   def tiun_args
+      tiun_context[action_name]&.args || []
+   end
+
+   def _permitted_filter
       @_permitted_filter ||= {}
-      @_permitted_filter[action_name] ||=
-         if c = self.class.instance_variable_get(:@context)[action_name]
-            c.args.map {|x|x.name}
+   end
+
+   def permitted_filter
+      _permitted_filter[action_name] ||=
+         if c = tiun_context[action_name]
+            (c.args || []).reject { |x| x.hidden }.map {|x| x.name }
          else
             [model.primary_key]
          end
    end
 
-   def permitted_self
+   def _permitted_self
       @_permitted_self ||= {}
-      @_permitted_self[action_name] ||=
-         if c = self.class.instance_variable_get(:@context)[action_name]
-            c.args.map {|x|x.name}
+   end
+
+   def permitted_self
+      _permitted_self[action_name] ||=
+         if c = tiun_context[action_name]
+            (c.args || []).reject { |x| x.hidden }.map {|x| x.kind == 'json' ? {x.name => {}} : x.name }
          else
             model.attribute_types.keys
          end
@@ -239,7 +240,7 @@ module Tiun::Base
             child_model = model.reflections[name.to_s].klass
             value = child_model.attribute_types.keys
             value << :_destroy if opts[:allow_destroy]
-            res[name] = value - supplement_names.map(&:to_s)
+            res["#{name}_attributes"] = value - supplement_names.map(&:to_s)
 
             res
          end
@@ -249,34 +250,28 @@ module Tiun::Base
       params.require(param_name).permit(*permitted_self, **permitted_children)
    end
 
-   def supplement_names
-      %i(created_at updated_at tsv)
-   end
-
    def total
-      %i(total_size total_count count).reduce(nil) do |count, method|
-         objects.respond_to?(method) && !count ? objects.send(method) : count
-      end
+      @total ||=
+         %i(total_size total_count count).reduce(nil) do |count, method|
+            objects.respond_to?(method) && !count ? objects.send(method) : count
+         end || raise
    end
 
    def paged_objects
       objects.range(range)
    end
 
-   def render_type type
-   end
-
    def get_properties
       @get_properties ||=
-         if k = self.class.instance_variable_get(:@context)[action_name]&.kind
-            Tiun.type_attributes_for(k)
+         if k = tiun_context[action_name]&.kind
+            Tiun.type_attributes_for(k, %i(read write))
          else
             model.attribute_types.keys
          end
    end
 
-   def serialize_collection collection
-      collection.jsonize(context.merge(only: get_properties))
+   def serialize_collection collection, context_in = {}
+      collection.jsonize(context.merge(context_in).merge(only: get_properties))
 #         format.json { render :index, json: objects, locales: locales,
 #                                      serializer: objects_serializer,
 #                                      each_serializer: serializer,
@@ -290,28 +285,23 @@ module Tiun::Base
 #         format.json { render :show, json: @object, locales: @locales,
 #                                     serializer: serializer }
    end
-   #
 
    def authorize!
-      binding.pry
-      if !policy.new(current_user, @object).send(action_name + '?')
+      pol = policy.new(current_user, @object)
+
+      if pol.respond_to?(action_name + "?") && !pol.send(action_name + "?") ||
+         pol.respond_to?(:match?) && !pol.match?(allowing_permission)
          raise Tiun::Policy::NotAuthorizedError, "not allowed to do #{action_name} this #{@object.inspect}"
       end
    end
 
    def per
       @per ||= (params[:per] ||
-         if args = self.class.instance_variable_get(:@context)[action_name]&.args
-            args.reduce(nil) { |res, x| res || x.name == "per" && x.default || nil }
-         end || 25).to_i
+         tiun_args.reduce(nil) { |res, x| res || x.name == "per" && x.default || nil } || 25).to_i
    end
 
    def page
-      @page ||= (params[:page] || 1).to_i
-   end
-
-   def locales
-      @locales ||= [I18n.locale]
+      @page ||= (params[:page] || params[:p] || 1).to_i
    end
 
    def set_tokens
@@ -328,6 +318,16 @@ module Tiun::Base
       @range
    end
 
+   def allowing_permission
+      if perm = tiun_context[action_name].policy
+         [perm].flatten.map { |x| x.split(",") }.flatten
+      end
+   end
+
+   def objects
+      @objects ||= with_others(objects_scope)
+   end
+
    # callbacks
    def parse_range
      @range =
@@ -344,27 +344,61 @@ module Tiun::Base
       @object = model.new(permitted_params)
    end
 
+   def fetch_object
+      @object = object_scope.first || raise(ActiveRecord::RecordNotFound)
+   end
+
    def fetch_objects
-      @objects = apply_scopes(model)#.page(params[:page])
+      @objects = objects
    end
 
-   def fetch_object
-      arg_name = default_arg
+   def fetch_ac_objects
+      @objects = apply_scopes(model)
+   end
+
+   def object_scope
+      apply_scope(model, [default_arg || model.primary_key])
+   end
+
+   def objects_scope
+      apply_scope(model, tiun_args.map { |a| a.name })
+   end
+
+   def apply_scope model = self.model, args = []
+      args.reduce(model) do |rel, arg|
+         next rel unless params.include?(arg)
+
+         if model.respond_to?("by_#{arg}")
+            rel.send("by_#{arg}", params[arg])
+         elsif model.respond_to?("by_#{arg.alias}")
+            rel.send("by_#{arg.alias}", params[arg])
+         elsif model.attribute_names.include?(arg.alias || arg.name)
+            rel.where({ arg => params[arg] })
+         else
+            raise InvalidParamNameError.new("Not valid rule to fetch object by #{arg_name} argument")
+         end
+      end
+   end
 
-      @object ||=
-         if !arg_name
-            model.find(params[model.primary_key])
-         elsif model.respond_to?("by_#{arg_name}")
-            model.send("by_#{arg_name}", params[arg_name]).first
+   def with_others rela
+      k = tiun_context[action_name]&.kind
+
+      Tiun.sublings_for(k, :write).reduce(rela) do |r, (sub, props)|
+         if r.respond_to?("with_#{sub}")
+            r.send("with_#{sub}", context.merge(only: props))
          else
-            model.where({ arg_name => params[arg_name] }).first
-         end || raise(ActiveRecord::RecordNotFound)
+            #TODO raise?
+            r
+         end
+      end
    end
 
    def return_range
+      response.headers["Access-Control-Expose-Headers"] = "Content-Range"
       response.headers["Accept-Ranges"] = "records"
       response.headers["Content-Range"] = "records #{range.begin}-#{range.end}/#{total}"
-      response.headers["Content-Length"] = [range.end + 1, total].min - range.begin
+      # NOTE: HTTP isn't supported range except bytes https://stackoverflow.com/a/9480391/446267
+      # response.headers["Content-Length"] = [range.end + 1, total].min - range.begin
    end
 end
 

data/lib/tiun/core_helper.rb

@@ -8,6 +8,14 @@ module ::Tiun::CoreHelper
       })
       content_tag(:div, '', html_options, &block)
    end
+
+   def current_user_data
+      @current_user&.jsonize(only:
+         ["id", "last_login_at", "last_active_at", "default_name", "refresh_token", "session_token",
+         "accounts" => %w(id no type),
+         "user_names" => %w(id kind way usage source main nomen_id name),
+         "descriptions" => %w(id language_code alphabeth_code type text)])
+   end
 end
 
 CoreHelper = ::Tiun::CoreHelper

data/lib/tiun/engine.rb

@@ -25,6 +25,7 @@ class Tiun::Engine < ::Rails::Engine
 
 #   config.autoload_paths += %W(#{Tiun::Engine.root}/lib/tiun/autoloads)
 #   config.autoload_paths += %W(#{Tiun::Engine.root}/lib/tiun/views)
+   config.i18n.load_path += Dir[Tiun::Engine.root.join('lib', 'config', 'locale', '**', '*.{yaml,yml}')]
 
    config.to_prepare do
       ::ActiveRecord::Base.extend(Tiun::Model)

data/lib/tiun/model/account.rb

@@ -0,0 +1,30 @@
+require 'tiun/model'
+
+module Tiun::Model::Account
+   class InvalidPasswordError < StandardError; end
+
+   def authenticated_user! password
+      user.match_password?(password) ? user : raise(InvalidPasswordError)
+   end
+
+   def create_validate_token
+      Token::Validate.create(tokenable: self)
+   end
+
+   def validate_token
+      tokina.where(type: "Token::Validate").first
+   end
+
+   class << self
+      def included kls
+         kls.module_eval do
+            belongs_to :user
+            has_many :tokina, as: :tokenable
+
+            after_create :create_validate_token
+         end
+      end
+   end
+end
+
+Model::Account = Tiun::Model::Account

data/lib/tiun/model/auth.rb

@@ -0,0 +1,88 @@
+require 'tiun/model'
+
+module Tiun::Model::Auth
+   class InvalidTokenError < StandardError; end
+
+   attr_reader :password, :password_confirmation
+
+   def password_confirmation= value
+      @password_confirmation = value
+   end
+
+   def password= value
+      @password = value
+   end
+
+   def fill_in_encrypted_password
+      self.encrypted_password = Tiun::Model::Auth.encrypt!(password) if password and quick_match_passwords?
+   end
+
+   def match_password? password
+      self.encrypted_password == Tiun::Model::Auth.encrypt!(password)
+   end
+
+   def quick_match_passwords?
+      password && password_confirmation && password == password_confirmation
+   end
+
+   def match_passwords?
+      self.password && self.password == password_confirmation ||
+         self.encrypted_password && (!password_confirmation || self.match_password?(password_confirmation))
+   end
+
+   def generate_session
+      {
+         session_token: Token::Session.create(tokenable: self),
+         refresh_token: Token::Refresh.create(tokenable: self)
+      }
+   end
+
+   def update_session token
+      refresh_token =
+         if token.is_a?(Token::Refresh)
+            token
+         elsif token.is_a?(Hash)
+            Token::Refresh.actual.find_by_code(token["code"])
+         end || raise(InvalidTokenError.new(token))
+
+      {
+         session_token: Token::Session.create(tokenable: self),
+         refresh_token: refresh_token
+      }
+   end
+
+   def current_session token = nil
+      refresh_token = Token::Refresh.find_by(tokenable: self)
+      session_token = Token::Session.find_by(tokenable: self)
+
+      { session_token: session_token, refresh_token: refresh_token }
+   end
+
+   def destroy_session token = nil
+      refresh_token = Token::Refresh.find_by(tokenable: self)
+      session_token = Token::Session.find_by(tokenable: self)
+
+      { session_token: session_token.destroy, refresh_token: refresh_token.destroy }
+   end
+
+   class << self
+      def encrypt! password
+         OpenSSL::HMAC.hexdigest("SHA256", "salt", password)
+      end
+
+      def included kls
+         kls.module_eval do
+            has_many :accounts
+            has_many :tokina, as: :tokenable
+
+            validates_presence_of :encrypted_password
+            validate :match_passwords?
+            before_validation :fill_in_encrypted_password
+
+            accepts_nested_attributes_for :accounts, reject_if: :all_blank, allow_destroy: true
+         end
+      end
+   end
+end
+
+Model::Auth = Tiun::Model::Auth

data/lib/tiun/model/token.rb

@@ -0,0 +1,13 @@
+require 'tiun/model'
+
+module Tiun::Model::Token
+   class << self
+      def included kls
+         kls.module_eval do
+            scope :actual, -> { where("expires_at >= ?", Time.zone.now) }
+         end
+      end
+   end
+end
+
+Model::Token = Tiun::Model::Token

data/lib/tiun/policy.rb

@@ -11,32 +11,12 @@ module Tiun::Policy
       true
    end
 
-   def all?
-      default?
-   end
-
-   def index?
-      default?
-   end
-
    def show?
       scope.where(id: record.id).exists?
    end
 
-   def create?
-      default?
-   end
-
-   def new?
-      default?
-   end
-
-   def update?
-      default?
-   end
-
-   def destroy?
-      default?
+   def match? allowing_permissions
+      (user.permissions & allowing_permissions).any?
    end
 
    def scope

data/lib/tiun/version.rb

@@ -1,5 +1,5 @@
 module Tiun
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end
 
 Version = Tiun::VERSION

data/lib/tiun.rb

@@ -11,6 +11,7 @@ require "tiun/version"
 require "tiun/migration"
 require "tiun/attributes"
 require "tiun/base"
+require "tiun/auth"
 require "tiun/core_helper"
 
 module Tiun
@@ -118,9 +119,7 @@ module Tiun
       end
 
       def controller_default_arg_for context
-         /:(?<arg>[^\.]+)/ =~ context.path
-
-         arg
+         context.key || /:(?<arg>[^\.]+)/.match(context.path)&.[](:arg)
       end
 
       def route_title_for context
@@ -159,21 +158,37 @@ module Tiun
          end unless type_names.blank?
       end
 
+      # generates a hash to collect all subling relation for the specificed kind type
+      #
+      def sublings_for type_name_in, kind_in = %i(read write)
+        kind = [kind_in].flatten
+
+        type_attributes_for(type_name_in, kind).reduce({}) do |res, value_in|
+           if value_in.is_a?(Hash)
+              res.merge(value_in)
+           else
+              res
+           end
+        end
+      end
+
       # +type_attributes_for+ renders attributes array for the type name or type itself specified,
       # if no type name has been found, it returns a blank array.
       #
-      def type_attributes_for type_name_in
+      def type_attributes_for type_name_in, kind = %i(read write)
          type = type_name_in.is_a?(OpenStruct) ? type_name_in : find_type(type_name_in)
 
          return [] unless type
 
          type.fields.map do |x|
+            next nil unless x.to_h.keys.select { |y| /only$/ =~ y }.reduce(kind)  { |k, prop| x[prop] ? ["#{prop}".sub("only","").to_sym] & k : k }.any?
+
             if sub = Tiun.find_type(x.kind)
-               { x.name => type_attributes_for(sub) }
+               { x.name => type_attributes_for(sub, kind) }
             else
                x.name
             end
-         end
+         end.compact
       end
 
       def detect_type type_in
@@ -194,9 +209,10 @@ module Tiun
             method_name = method.name
             rule = MAP[method_name]
 
-            action = rule.is_a?(String) && rule || rule.reduce(nil) do |a, (re, action)|
-               a || context.path =~ re && action || nil
-            end
+            action =
+               method.action || (rule.is_a?(String) && rule || rule.reduce(nil) do |a, (re, action)|
+                  a || context.path =~ re && action || nil
+               end)
 
             # TODO validated types
             if ! action
@@ -235,7 +251,7 @@ module Tiun
       rescue NoMethodError
          error :no_resources_section_defined_in_config, {config: config, default: default}
 
-         []
+         default
       end
 
       def load_defaults_from config
@@ -378,12 +394,24 @@ module Tiun
       rescue NameError
       end
 
-      def base_model
-         @base_model ||= ActiveRecord::Base
+      def table_exist? name
+         ActiveRecord::Base.connection.data_source_exists?(name.to_s.tableize)
+      end
+
+      def base_model name = nil
+         @base_model ||= table_exist?(name) ? ActiveRecord::Base : ActiveModel::Model
       end
 
       def base_controller
-         @base_controller ||= ActionController::Base
+         @base_controller ||= defined?(ApplicationController) ? ApplicationController : ActionController::Base
+      end
+
+      def template_controller_for context
+         t = context.template&.camelize
+
+         self.const_get(t).const_get(:Controller)
+      rescue NameError, TypeError
+         ::Tiun::Base
       end
 
       def error code, options
@@ -486,6 +514,5 @@ module Tiun
 #   end
 end
 
-require "tiun/base"
 require "tiun/policy"
 require "tiun/engine"

data/tiun.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = %q{Tiun is a backend gem for admin rails application.}
   spec.description   = %q{Tiun is an old russian high level manager for a city from a prince or boyar. According the repo tiun is a backend gem for admin rails application.}
-  spec.homepage      = "https://github.com/majioa/tiun"
+  spec.homepage      = "https://codeberg.org/znamenica/tiun"
   spec.license       = "MIT"
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tiun
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Malo Skrylevo
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-31 00:00:00.000000000 Z
+date: 2024-05-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -290,12 +290,15 @@ files:
 - bin/console
 - bin/setup
 - exe/tiun
+- lib/config/locale/ru.yml
 - lib/config/routes.rb
 - lib/layouts/tiun.html.erb
 - lib/tiun.rb
 - lib/tiun/actor.rb
 - lib/tiun/actor/validate.rb
 - lib/tiun/attributes.rb
+- lib/tiun/auth.rb
+- lib/tiun/auth/controller.rb
 - lib/tiun/autocontroller.rb.erb
 - lib/tiun/autolistserializer.rb.erb
 - lib/tiun/automigration.rb.erb
@@ -312,11 +315,14 @@ files:
 - lib/tiun/migration.rb
 - lib/tiun/mixins.rb
 - lib/tiun/model.rb
+- lib/tiun/model/account.rb
+- lib/tiun/model/auth.rb
+- lib/tiun/model/token.rb
 - lib/tiun/policy.rb
 - lib/tiun/serializer.rb
 - lib/tiun/version.rb
 - tiun.gemspec
-homepage: https://github.com/majioa/tiun
+homepage: https://codeberg.org/znamenica/tiun
 licenses:
 - MIT
 metadata: