command_tower 0.3.0

data/app/services/command_tower/argument_validation/class_methods.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module CommandTower::ArgumentValidation
+  module ClassMethods
+    ON_ARGUMENT_VALIDATION = [
+      DEFAULT_VALIDATION = :raise,
+      :fail_early,
+      :log,
+    ]
+
+    def on_argument_validation_assigned
+      @on_argument_validation ||= DEFAULT_VALIDATION
+    end
+
+    def on_argument_validation(set)
+      raise "Must be one of #{ON_ARGUMENT_VALIDATION}" unless ON_ARGUMENT_VALIDATION.include?(set)
+
+      @on_argument_validation = set
+    end
+
+    def compose_exact(count, name, required:, delegation: false, &block)
+      raise CommandTower::ServiceBase::CompositionValidationError, "Count must be greater than 0" if count < 1
+
+      validation_proc = Proc.new do |input_count, keys|
+        language = (input_count > 0) ? "But #{input_count} keys were assigned" : "But no key was assigned"
+        {
+          message: "Expected [#{count}] of the keys to have a value assigned. #{language}",
+          is_valid: (input_count == count),
+          requirement: "Exactly #{count} key(s) of #{keys} must be provided.",
+        }
+      end
+
+      composition_validation_proc = Proc.new do
+        keys = compositions[__stacked_type.last[:name]][:keys]
+        if keys.length < count
+          raise CommandTower::ServiceBase::CompositionValidationError, "Composition configuration error. Key [#{name}] expects EXACTLY #{count} keys to create an instance. Only #{keys.length} is provided for the composition. Please add more keys or reduce the expectation"
+        end
+      end
+      composition(name:, type: :compose_exact, required:, delegation:, composition_validation_proc:, validation_proc:, &block)
+    end
+
+    def at_most(count, name, required:, &block)
+      raise CommandTower::ServiceBase::CompositionValidationError, "Count must be greater than 0" if count < 1
+
+      validation_proc = Proc.new do |input_count, keys|
+        {
+          message: "Expected at most #{count} keys assigned",
+          is_valid: (input_count <= count),
+          requirement: "Validation Error: At most #{count} key(s) of #{keys} can be provided.",
+        }
+      end
+
+      composition(name:, type: :at_most, required:, delegation: false, validation_proc:, &block)
+    end
+
+    def at_least(count, name, required:, &block)
+      raise CommandTower::ServiceBase::CompositionValidationError, "Count must be greater than 0" if count < 1
+
+      validation_proc = Proc.new do |input_count, keys|
+        {
+          message: "Expected at least #{count} keys assigned. Available keys",
+          is_valid: (input_count >= count),
+          requirement: "Validation Error: At least #{count} key(s) of #{keys} must be provided.",
+        }
+      end
+
+      composition_validation_proc = Proc.new do
+        keys = compositions[__stacked_type.last[:name]][:keys]
+        if keys.length < count
+          raise CommandTower::ServiceBase::CompositionValidationError, "Composition configuration error. Key [#{name}] expects AT LEAST #{count} keys to create an instance. Only #{keys.length} is provided for the composition. Please add more keys or reduce the expectation"
+        end
+      end
+      composition(name:, type: :at_least, required:, delegation: false, composition_validation_proc:, validation_proc:, &block)
+    end
+
+    def at_least_one(name, required:, &block)
+      at_least(1, name, required:, &block)
+    end
+
+    def one_of(name, required:, delegation: true, &block)
+      compose_exact(1, name, required:, delegation:, &block)
+    end
+
+    def composition(name:, type:, required:, delegation:, validation_proc:, composition_validation_proc: nil, &block)
+      compositions[name] ||= { type:, name:, keys: [], required:, delegation:, validation_proc: }
+      if __stacked_type.map { _1[:type] }.include?(type)
+        raise CommandTower::ServiceBase::NestedDuplicateTypeError, "Duplicate Nested type's are not allowed. #{type} composition was included more than once"
+      end
+
+      __stacked_type << { type:, name: }
+
+      yield
+
+      if composition_validation_proc
+        composition_validation_proc.()
+      end
+
+      if __existing_names.include?(name)
+        raise CommandTower::ServiceBase::NameConflictError, "Name conflict for #{name}. Duplicated as a key"
+      end
+
+      __existing_names << name
+      # returning from the yield...pop it from the stack.
+      # This allows us to know the current depth of where we are in the nested stack
+      __stacked_type.pop
+
+      if delegation
+        delegate name, to: :context
+        delegate :"#{name}_key", to: :context
+      end
+    end
+
+    def validate(name, default: nil, length: false, is_a: nil, is_one: nil, lt: nil, lte: nil, eq: nil, gt: nil, gte: nil, delegation: true, sensitive: false, required: false)
+      if __existing_names.include?(name)
+        raise CommandTower::ServiceBase::NameConflictError, "Duplicate key name found. [#{name}] can only be defined once"
+      end
+
+      __existing_names << name
+
+      if default
+        if is_a
+          if Array(is_a).none? { _1 === default }
+            raise CommandTower::ServiceBase::DefaultValueError, "Default value provided [#{default}] does not match any `is_a` value(s) of #{is_a}."
+          end
+        end
+
+        if is_one
+          if Array(is_one).none? { _1 == default }
+            raise CommandTower::ServiceBase::DefaultValueError, "Default value provided [#{default}] does not match any `is_one` value(s) of #{is_one}."
+          end
+        end
+      end
+
+      if __stacked_type.length > 0
+        compositions[__stacked_type.last[:name]][:keys] << name
+      end
+
+      validate_params << {
+        name:,
+        is_a:,
+        lt:,
+        lte:,
+        eq:,
+        gt:,
+        gte:,
+        length:,
+        required:,
+        is_one:,
+        default:,
+      }
+      sensitive_params << name if sensitive
+
+      if delegation
+        delegate name, to: :context
+      end
+    end
+
+    def sensitive_params
+      @sensitive_params ||= []
+    end
+
+    def validate_params
+      @validate_params ||= []
+    end
+
+    def compositions
+      @compositions ||= {}
+    end
+
+    def __stacked_type
+      @__stacked_type ||= []
+    end
+
+    def __existing_names
+      @__existing_names ||= []
+    end
+  end
+end

data/app/services/command_tower/argument_validation/instance_methods.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module CommandTower::ArgumentValidation
+  module InstanceMethods
+    def run_validations!
+      context.valid_arguments = true
+
+      validate_param!
+      validate_compositions!
+      continue_with_logical_code!
+    end
+
+    def continue_with_logical_code!
+      return if @context_validation_failures.nil?
+
+      invalid_argument_keys = @context_validation_failures.keys
+      msg = @context_validation_failures.map { |_k, obj| obj[:msg] }.join(", ")
+      context.fail!(msg:, invalid_argument_hash: @context_validation_failures, invalid_argument_keys:, invalid_arguments: true)
+    end
+
+    def inline_argument_failure!(errors:)
+      errors = errors.to_hash
+      invalid_argument_keys = errors.keys
+      invalid_argument_hash = {}
+      human_readable = []
+
+      errors.each do |k, v|
+        error_message = Array(v).join(", ")
+        invalid_argument_hash[k] = { msg: error_message }
+        human_readable << "#{k}: #{error_message}"
+      end
+
+      msg = "Invalid arguments: #{human_readable.join(", ")}"
+      context.fail!(msg:, invalid_argument_hash:, invalid_argument_keys:, invalid_arguments: true)
+    end
+
+    def validate_param!
+      self.class.validate_params.each do |metadata|
+        value = context.public_send(metadata[:name])
+        use_length = metadata[:length]
+        if metadata[:required] && value.nil?
+          __failed_argument_validation(msg: "Parameter [#{metadata[:name]}] is required but not present", argument: metadata[:name], metadata:)
+        end
+
+        if value.nil? && metadata[:default]
+          context.public_send(:"#{metadata[:name]}=", metadata[:default])
+          next
+        elsif value.nil?
+          next
+        end
+
+        if is_a = metadata[:is_a]
+          direct_type = false
+          ancestor_type = false
+
+          # Check if direct type of `is_a` Integer === 5 => true
+          direct_type = Array(is_a).none? { _1 === value }
+
+          # If it is a direct type, we dont need to do any other type of checking
+          if direct_type == true
+            lineage = value.ancestors rescue []
+            # Check inclusion in ancestor list
+            ancestor_type = Array(is_a).none? { lineage.include?(_1) }
+          end
+          if direct_type && ancestor_type
+            __failed_argument_validation(msg: "Parameter [#{metadata[:name]}] must be of type #{is_a}. Given #{value.class} [#{value}]", argument: metadata[:name], metadata:)
+          end
+        end
+
+        if metadata[:is_one]
+          if Array(metadata[:is_one]).none? { _1 == value }
+            __failed_argument_validation(msg: "Parameter [#{metadata[:name]}] must be one of #{Array(metadata[:is_one])}. Given #{value}", argument: metadata[:name], metadata:)
+          end
+        end
+
+        validate_sign!(name: metadata[:name], value:, sign: "lt", validation: metadata[:lte], use_length:, metadata:) { (use_length ? value.length : value) <= _1 }
+        validate_sign!(name: metadata[:name], value:, sign: "lte", validation: metadata[:lt], use_length:, metadata:) { (use_length ? value.length : value) < _1 }
+        validate_sign!(name: metadata[:name], value:, sign: "eq", validation: metadata[:eq], use_length:, metadata:) { (use_length ? value.length : value) == _1 }
+        validate_sign!(name: metadata[:name], value:, sign: "gte", validation: metadata[:gte], use_length:, metadata:) { (use_length ? value.length : value) >= _1 }
+        validate_sign!(name: metadata[:name], value:, sign: "gt", validation: metadata[:gt], use_length:, metadata:) { (use_length ? value.length : value) > _1 }
+      end
+    end
+
+    def validate_compositions!
+      self.class.compositions.each do |type, metadata|
+        value_list = {}
+
+        metadata[:keys].each do |argument|
+          value = context.public_send(argument)
+          next if value.nil?
+
+          value_list[argument] = value
+        end
+
+        composition_result = metadata[:validation_proc].(value_list.count, value_list.keys)
+
+        next if value_list.count == 0 && !metadata[:required]
+
+        if !composition_result[:is_valid]
+          composition_result[:message]
+          context.client_composite_error = composition_result[:requirement]
+          msg = "Composite Key failure for #{type} [#{metadata[:name]}]. #{composition_result[:message]}. Provided values for the following keys: #{value_list.keys}. Available keys #{metadata[:keys]}"
+          __failed_argument_validation(msg:, argument: metadata[:name], metadata: ,error: CommandTower::ServiceBase::CompositionValidationError)
+          next
+        end
+
+        if metadata[:delegation]
+          context.public_send("#{metadata[:name]}=", value_list.first[1])
+          context.public_send("#{metadata[:name]}_key=", value_list.first[0])
+        end
+      end
+    end
+
+    def validate_sign!(name:, value:, sign:, validation:, use_length:, metadata:)
+      return if validation.nil?
+      return if yield(validation)
+
+      __failed_argument_validation(metadata:, msg: "Parameter [#{name}]#{ " lengths" if use_length} must be #{sign} to #{validation}. Given #{value}", argument: name)
+    end
+
+    def __failed_argument_validation(msg:, argument:, metadata:, error: CommandTower::ServiceBase::ArgumentValidationError)
+      case self.class.on_argument_validation_assigned
+      when :raise
+        raise error, msg
+      when :fail_early
+        @context_validation_failures ||= {}
+        @context_validation_failures[argument] = {
+          msg: msg,
+          required: metadata[:requirement],
+          is_a: metadata[:is_a],
+        }
+        # When gracefully failing, it will find all failures first before setting appropriate
+        # context variables -- Check out continue_with_logical_code!
+      else
+        context.invalid_arguments = true
+        log_warn(msg)
+      end
+    end
+
+    def sanitize_params
+      self.class.sensitive_params.each do |param|
+        next if context.send(param).nil?
+
+        context.send("#{param}=","[FILTERED]")
+      end
+    end
+  end
+end

data/app/services/command_tower/argument_validation.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CommandTower::ArgumentValidation
+  class NameConflictError < CommandTower::ServiceBase::ConfigurationError; end
+  class NestedDuplicateTypeError < CommandTower::ServiceBase::ConfigurationError; end
+
+  def self.included(base)
+    base.extend(CommandTower::ArgumentValidation::ClassMethods)
+    base.include(CommandTower::ArgumentValidation::InstanceMethods)
+  end
+end

data/app/services/command_tower/authorize/validate.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module CommandTower::Authorize
+  class Validate < CommandTower::ServiceBase
+    on_argument_validation :fail_early
+
+    validate :user, is_a: User, required: true
+    validate :controller, is_a: [ActionController::Base, ActionController::API], required: true
+    validate :method, is_a: String, required: true
+
+    def call
+      context.authorization_required = authorization_required?
+      unless context.authorization_required
+        log_info("controller:#{controller}; method:#{method} -- No Authorization required")
+        context.msg = "Authorization not required at this time"
+        return
+      end
+
+      # At this point we know authorization on the route is required
+      # Iterate through the users roles to find a matching role that allows authorization
+      # If at least 1 of the users roles passes validation, we can allow access to the path
+      log_info("User Roles: #{user.roles}")
+      auhorization_result = user_role_objects.any? do |_role_name, role_object|
+        result = role_object.authorized?(controller:, method:, user:)
+        log_info("Role:#{result[:role]};Authorized:[#{result[:authorized]}];Reason:[#{result[:reason]}]")
+        result[:authorized] == true
+      end
+
+      if auhorization_result
+        context.msg = "User is Authorized for action"
+      else
+        context.fail!(msg: "Unauthorized Access. Incorrect User Privileges")
+      end
+    end
+
+    def authorization_required?
+      controller_mapping = CommandTower::Authorization.mapped_controllers[controller]
+      return false if controller_mapping.nil?
+
+      controller_mapping.include?(method.to_sym)
+    end
+
+    def user_role_objects
+      CommandTower::Authorization::Role.roles.select do |role_name, _|
+        user.roles.include?(role_name.to_s)
+      end
+    end
+  end
+end

data/app/services/command_tower/inbox_service/blast/delete.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module InboxService
+    module Blast
+      class Delete < CommandTower::ServiceBase
+        on_argument_validation :fail_early
+
+        validate :id, is_a: Integer, required: true
+
+        def call
+          message_blast = ::MessageBlast.where(id:).first
+
+          if message_blast.nil?
+            inline_argument_failure!(errors: { id: "MessageBlast ID not found" })
+          end
+
+          message_blast.destroy
+        end
+      end
+    end
+  end
+end

data/app/services/command_tower/inbox_service/blast/metadata.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module InboxService
+    module Blast
+      class Metadata  < CommandTower::ServiceBase
+        def call
+          entities = ::MessageBlast.all.select(:id, :title, :existing_users, :new_users).map do |mb|
+            CommandTower::Schema::Inbox::MessageBlastEntity.new(
+              title: mb.title,
+              id: mb.id,
+              existing_users: mb.existing_users,
+              new_users: mb.new_users,
+            )
+          end
+
+
+          context.metadata = CommandTower::Schema::Inbox::MessageBlastMetadata.new(
+            entities: entities,
+            count: entities.length,
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/command_tower/inbox_service/blast/new_user_blaster.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module InboxService
+    module Blast
+      class NewUserBlaster  < CommandTower::ServiceBase
+        on_argument_validation :fail_early
+
+        validate :user, is_a: User, required: true
+
+        def call
+          ::MessageBlast.where(new_users: true).each do |message_blast|
+            InboxService::Message::Send.(
+              user:,
+              text: message_blast.text,
+              title: message_blast.title,
+              message_blast:,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/services/command_tower/inbox_service/blast/retrieve.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module InboxService
+    module Blast
+      class Retrieve < CommandTower::ServiceBase
+        on_argument_validation :fail_early
+
+        validate :id, is_a: Integer, required: true
+
+        def call
+          message_blast = ::MessageBlast.where(id:).first
+
+          if message_blast.nil?
+            inline_argument_failure!(errors: { id: "MessageBlast ID not found" })
+          end
+
+          context.message_blast = CommandTower::Schema::Inbox::MessageBlastEntity.new(
+            created_by: CommandTower::Schema::User.convert_user_object(user: message_blast.user),
+            title: message_blast.title,
+            text: message_blast.text,
+            id: message_blast.id,
+            existing_users: message_blast.existing_users,
+            new_users: message_blast.new_users,
+          )
+        end
+      end
+    end
+  end
+end

data/app/services/command_tower/inbox_service/blast/upsert.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module InboxService
+    module Blast
+      class Upsert  < CommandTower::ServiceBase
+        on_argument_validation :fail_early
+
+        validate :user, is_a: User, required: true
+        validate :existing_users, is_one: [true, false], required: true
+        validate :new_users, is_one: [true, false], required: true
+        validate :text, is_a: String, required: true
+        validate :title, is_a: String, required: true
+        validate :id, is_a: Integer, required: false
+
+        def call
+          ar = record
+
+          ar.existing_users = existing_users
+          ar.new_users = new_users
+          ar.text = text
+          ar.title = title
+          ar.user = user
+
+          # Probably should wrap this in a transaction block
+          ar.save!
+          blast_messages!(message_blast: ar)
+
+          context.message_blast = ar
+          context.blast = CommandTower::Schema::Inbox::BlastResponse.new(
+            existing_users:,
+            new_users:,
+            text:,
+            title:,
+            id: ar.id,
+            created_by: CommandTower::Schema::User.convert_user_object(user:)
+          )
+        end
+
+        def blast_messages!(message_blast:)
+          # Only blast messages to existing users that are brand new
+          return if @existing_record
+          return unless existing_users
+
+          User.all.each do |u|
+            InboxService::Message::Send.(
+              user: u,
+              text: text,
+              title: title,
+              message_blast: message_blast,
+            )
+          end
+        end
+
+        def record
+          return MessageBlast.new if id.nil?
+
+          record = MessageBlast.where(id:).first
+          inline_argument_failure!(errors: { id: "Message Blast ID does not exist" }) if record.nil?
+
+          @existing_record = true
+          record
+        end
+      end
+    end
+  end
+end

data/app/services/command_tower/inbox_service/message/metadata.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module InboxService
+    module Message
+      class Metadata < CommandTower::ServiceBase
+        on_argument_validation :fail_early
+
+        validate :user, is_a: User, required: true
+
+        def call
+          entities = ::Message.where(user:).select(:id, :title, :viewed).map do |message|
+            CommandTower::Schema::Inbox::MessageEntity.new(
+              title:  message.title,
+              id:  message.id,
+              viewed:  message.viewed,
+            )
+          end
+
+          params = {
+            entities: entities.nil? ? nil : entities,
+            count: entities.length,
+          }
+
+          context.metadata = CommandTower::Schema::Inbox::Metadata.new(**params.compact)
+        end
+      end
+    end
+  end
+end
+
+
+
+
+

data/app/services/command_tower/inbox_service/message/modify.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module InboxService
+    module Message
+      class Modify < CommandTower::ServiceBase
+        on_argument_validation :fail_early
+
+        IS_ONE = [
+          VIEWED = :viewed,
+          DELETE = :delete,
+        ]
+        validate :user, is_a: User, required: true
+        validate :ids, is_a: Array, required: true
+        validate :type, is_one: IS_ONE, required: true
+
+        def call
+          messages = ::Message.where(user:, id: ids)
+          if messages.empty?
+            inline_argument_failure!(errors: { ids: "No ID's found for user" })
+          end
+
+          case type
+          when VIEWED
+            modified_ids = messages.update(viewed: true).pluck(:id)
+          when DELETE
+            modified_ids = messages.destroy_all.pluck(:id)
+          end
+
+          context.modified = CommandTower::Schema::Inbox::Modified.new(
+            ids: modified_ids,
+            type:,
+            count: modified_ids.length,
+          )
+        end
+      end
+    end
+  end
+end
+
+
+
+
+

data/app/services/command_tower/inbox_service/message/retrieve.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module InboxService
+    module Message
+      class Retrieve < CommandTower::ServiceBase
+        on_argument_validation :fail_early
+
+        validate :user, is_a: User, required: true
+        validate :id, is_a: Integer, required: true
+
+        def call
+          message = ::Message.where(user:, id:).first
+
+          if message.nil?
+            inline_argument_failure!(errors: { id: "Message ID not found for user" })
+          end
+
+          message.update!(viewed: true)
+
+          context.message = CommandTower::Schema::Inbox::MessageEntity.new(
+            title: message.title,
+            id: message.id,
+            text: message.text,
+            viewed: message.viewed,
+          )
+        end
+      end
+    end
+  end
+end
+
+
+
+
+