command_tower 0.4.0 → 0.10.0

data/app/controllers/command_tower/admin_controller.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-module CommandTower
-  class AdminController < ::CommandTower::ApplicationController
-    include CommandTower::SchemaHelper
-    include CommandTower::PaginationHelper
-
-    before_action :authenticate_user!
-    before_action :authorize_user!
-    before_action :user!, only: [:modify, :modify_role]
-
-    # GET: /admin
-    # Pagination Available
-    def show
-      schema = CommandTower::AdminService::Users.(
-        user: admin_user,
-        pagination: pagination_values,
-      ).schema
-      schema_succesful!(status: 200, schema:)
-    end
-
-    # POST: /modify
-    def modify
-      result = CommandTower::UserAttributes::Modify.(user:, admin_user:, **modify_params)
-      if result.success?
-        schema = CommandTower::Schema::User.convert_user_object(user: user.reload)
-        status = 201
-        schema_succesful!(status:, schema:)
-      else
-        if result.invalid_arguments
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::PlainText::LoginRequest
-          )
-        else
-          server_error!(result:)
-        end
-      end
-    end
-
-    # POST: /modify/role
-    def modify_role
-      result = CommandTower::UserAttributes::Roles.(user:, admin_user:, roles: params[:roles] || [])
-      if result.success?
-        schema = CommandTower::Schema::User.convert_user_object(user: user.reload)
-        status = 201
-        schema_succesful!(status:, schema:)
-      else
-        if result.invalid_arguments
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::PlainText::LoginRequest
-          )
-        else
-          server_error!(result:)
-        end
-      end
-    end
-
-    def impersonate
-      # TODO: @matt-taylor
-    end
-
-    private
-
-    def server_error!(result:)
-      status = 500
-      schema = CommandTower::Schema::Error::Base.new(status:, message: result.msg)
-      render(json: schema.to_h, status:)
-    end
-
-    def modify_params
-      {
-        email: params[:email],
-        email_validated: safe_boolean(value: params[:email_validated]),
-        first_name: params[:first_name],
-        last_name: params[:last_name],
-        username: params[:username],
-        verifier_token: safe_boolean(value: params[:verifier_token]),
-      }.compact
-    end
-
-    def admin_user
-      # current_user is defined via authenticate_user! before action
-      current_user
-    end
-
-    def user!
-      _user = User.where(id: params[:user_id]).first
-      if _user
-        @user = _user
-        return true
-      end
-
-      status = 400
-      schema = CommandTower::Schema::Error::Base.new(status:, message: "Invalid user")
-      render(json: schema.to_h, status:)
-      # Must return false so callbacks know to halt propagation
-      false
-    end
-
-    def user
-      @user ||= nil
-    end
-  end
-end

data/app/controllers/command_tower/auth/plain_text_controller.rb

@@ -1,133 +0,0 @@
-module CommandTower
-  module Auth
-    class PlainTextController < ::CommandTower::ApplicationController
-      include CommandTower::SchemaHelper
-
-      before_action :authenticate_user_without_email_verification!, only: [:email_verify_post, :email_verify_resend_post]
-
-      # POST /auth/login
-      # Login to the application and create/set the JWT token
-      def login_post
-        result = CommandTower::LoginStrategy::PlainText::Login.(**login_params)
-        if result.success?
-          schema = CommandTower::Schema::PlainText::LoginResponse.new(
-            token: result.token,
-            header_name: AUTHENTICATION_HEADER,
-            user: CommandTower::Schema::User.convert_user_object(user: result.user),
-            message: "Successfully logged user in"
-          )
-          status = 201
-          schema_succesful!(status:, schema:)
-        else
-          if result.invalid_arguments
-            invalid_arguments!(
-              status: 401,
-              message: result.msg,
-              argument_object: result.invalid_argument_hash,
-              schema: CommandTower::Schema::PlainText::LoginRequest
-            )
-          else
-            json_result = { msg: result.msg }
-            status = 400
-            render(json: schema.to_h, status:)
-          end
-        end
-      end
-
-      # POST /auth/create
-      # New PlainText user creation
-      def create_post
-        result = CommandTower::LoginStrategy::PlainText::Create.(**create_params)
-        if result.success?
-          schema = CommandTower::Schema::PlainText::CreateUserResponse.new(
-            full_name: result.user.full_name,
-            first_name: result.first_name,
-            last_name: result.last_name,
-            username: result.username,
-            email: result.email,
-            msg: "Successfully created new User",
-          )
-          status = 201
-          schema_succesful!(status:, schema:)
-        else
-          if result.invalid_arguments
-            invalid_arguments!(
-              status: 400,
-              message: result.msg,
-              argument_object: result.invalid_argument_hash,
-              schema: CommandTower::Schema::PlainText::CreateUserRequest
-            )
-          end
-        end
-      end
-
-      # POST /auth/email/verify
-      # Verifies a logged in users email verification code when enabled
-      def email_verify_post
-        if current_user.email_validated
-          schema = CommandTower::Schema::PlainText::EmailVerifyResponse.new(message: "Email is already verified.")
-          status = 200
-          schema_succesful!(status:, schema:)
-        else
-          result = CommandTower::LoginStrategy::PlainText::EmailVerification::Verify.(user: current_user, code: params[:code])
-          if result.success?
-            schema = CommandTower::Schema::PlainText::EmailVerifyResponse.new(message: "Successfully verified email")
-            status = 201
-            schema_succesful!(status:, schema:)
-          else
-            if result.invalid_arguments
-              invalid_arguments!(
-                status: result.status || 403,
-                message: result.msg,
-                argument_object: result.invalid_argument_hash,
-                schema: CommandTower::Schema::PlainText::EmailVerifyRequest
-              )
-            end
-          end
-        end
-      end
-
-      # POST /auth/email/send
-      # Sends a logged in users email verification code
-      def email_verify_resend_post
-        if current_user.email_validated
-          schema = CommandTower::Schema::PlainText::EmailVerifyResponse.new(message: "Email is already verified. No code required")
-          status = 200
-          schema_succesful!(status:, schema:)
-        else
-          result = CommandTower::LoginStrategy::PlainText::EmailVerification::Send.(user: current_user)
-          if result.success?
-            schema = CommandTower::Schema::PlainText::EmailVerifyResponse.new(message: "Successfully sent Email verification code")
-            status = 201
-            schema_succesful!(status:, schema:)
-          else
-            schema = CommandTower::Schema::Error::Base.new(status:, message: result.msg)
-            status = result.status || 401
-            render(json: schema.to_h, status:)
-          end
-        end
-      end
-
-      private
-
-      def login_params
-        {
-          username: params[:username],
-          email: params[:email],
-          password: params[:password],
-        }
-      end
-
-      def create_params
-        {
-          first_name: params[:first_name],
-          last_name: params[:last_name],
-          username: params[:username],
-          email: params[:email],
-          password: params[:password],
-          password_confirmation: params[:password_confirmation],
-        }
-      end
-    end
-  end
-end

data/app/controllers/command_tower/inbox/message_blast_controller.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module CommandTower
-  module Inbox
-    class MessageBlastController < ::CommandTower::ApplicationController
-      include CommandTower::SchemaHelper
-
-      before_action :authenticate_user!
-      before_action :authorize_user!
-
-      # GET /inbox/blast
-      def metadata
-        result = CommandTower::InboxService::Blast::Metadata.(id: params[:id].to_i)
-        schema_succesful!(status: 200, schema: result.metadata)
-      end
-
-      # GET /inbox/blast/:id
-      def blast
-        result = CommandTower::InboxService::Blast::Retrieve.(id: params[:id].to_i)
-        if result.success?
-          schema = result.message_blast
-          status = 200
-          schema_succesful!(status:, schema:)
-        else
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::PlainText::LoginRequest,
-          )
-        end
-      end
-
-      # POST /inbox/blast
-      def create
-        upsert
-      end
-
-      # PATCH /inbox/blast/:id
-      def modify
-        upsert(id: params[:id].to_i)
-      end
-
-      # DELETE /inbox/blast/:id
-      def delete
-        result = CommandTower::InboxService::Blast::Delete.(id: params[:id].to_i)
-        if result.success?
-          schema = result.message
-          status = 200
-          render :json, { id: params[:id], msg: "Message Blast message deleted" }
-        else
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::PlainText::LoginRequest,
-          )
-        end
-      end
-
-      private
-
-      def upsert(id: nil)
-        upsert_params = {
-          user: current_user,
-          existing_users: safe_boolean(value: params[:existing_users]),
-          new_users: safe_boolean(value: params[:new_users]),
-          text: params[:text],
-          title: params[:title],
-          id:,
-        }.compact
-        result = CommandTower::InboxService::Blast::Upsert.(**upsert_params)
-
-        if result.success?
-          schema = result.blast
-          status = 200
-          schema_succesful!(status:, schema:)
-        else
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::Inbox::BlastRequest
-          )
-        end
-      end
-    end
-  end
-end

data/app/controllers/command_tower/inbox/message_controller.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module CommandTower
-  module Inbox
-    class MessageController < ::CommandTower::ApplicationController
-      include CommandTower::SchemaHelper
-      include CommandTower::PaginationHelper
-
-      before_action :authenticate_user!
-
-      # GET: /inbox/messages
-      # Pagination Available
-      def metadata
-        result = CommandTower::InboxService::Message::Metadata.(user: current_user, pagination: pagination_values)
-        if result.success?
-          schema = result.metadata
-          status = 200
-          schema_succesful!(status:, schema:)
-        else
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::PlainText::LoginRequest
-          )
-        end
-      end
-
-      # GET: /inbox/messages/:id
-      def message
-        result = CommandTower::InboxService::Message::Retrieve.(user: current_user, id: params[:id].to_i)
-        if result.success?
-          schema = result.message
-          status = 200
-          schema_succesful!(status:, schema:)
-        else
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::PlainText::LoginRequest
-          )
-        end
-      end
-
-      # POST: /inbox/messages/ack
-      # Body { ids: [<list of ids to ack>] }
-      def ack
-        modify(type: CommandTower::InboxService::Message::Modify::VIEWED)
-      end
-
-      # POST: /inbox/messages/delete
-      # Body { ids: [<list of ids to delete>] }
-      def delete
-        modify(type: CommandTower::InboxService::Message::Modify::DELETE)
-      end
-
-      private
-
-      def modify(type:)
-        result = CommandTower::InboxService::Message::Modify.(
-          user: current_user,
-          ids: params[:ids],
-          type:,
-        )
-        if result.success?
-          schema = result.modified
-          status = 200
-          schema_succesful!(status:, schema:)
-        else
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::PlainText::LoginRequest
-          )
-        end
-      end
-    end
-  end
-end

data/app/controllers/command_tower/user_controller.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module CommandTower
-  class UserController < ::CommandTower::ApplicationController
-    include CommandTower::SchemaHelper
-
-    before_action :authenticate_user!
-
-    def show
-      schema = CommandTower::Schema::User.convert_user_object(user: current_user)
-      schema_succesful!(status: 200, schema:)
-    end
-
-    def modify
-      result = CommandTower::UserAttributes::Modify.(user: current_user, **modify_params)
-      if result.success?
-        schema = CommandTower::Schema::User.convert_user_object(user: current_user.reload)
-        status = 201
-        schema_succesful!(status:, schema:)
-      else
-        if result.invalid_arguments
-          invalid_arguments!(
-            status: 400,
-            message: result.msg,
-            argument_object: result.invalid_argument_hash,
-            schema: CommandTower::Schema::PlainText::LoginRequest
-          )
-        else
-          status = 500
-          schema = CommandTower::Schema::Error::Base.new(status:, message: result.msg)
-          render(json: schema.to_h, status:)
-        end
-      end
-    end
-
-    private
-
-    def modify_params
-      {
-        email: params[:email],
-        email_validated: safe_boolean(value: params[:email_validated]),
-        first_name: params[:first_name],
-        last_name: params[:last_name],
-        username: params[:username],
-        verifier_token: safe_boolean(value: params[:verifier_token]),
-      }.compact
-    end
-  end
-end

data/app/controllers/command_tower/username_controller.rb

@@ -1,26 +0,0 @@
-module CommandTower
-  class UsernameController < ::CommandTower::ApplicationController
-
-    # GET /username/available/:username
-    def username_availability
-      result = CommandTower::Username::Available.(username: params[:username])
-
-      if result.success?
-        json_result = {
-          username: {
-            available: result.available,
-            valid: result.valid,
-            description: CommandTower.config.username.username_failure_message
-          }
-        }
-        status = 200
-      else
-        json_result = { msg: result.msg }
-        json_result[:invalid_arguments] = true if result.invalid_arguments
-        status = 401
-      end
-
-      render json: json_result, status: status
-    end
-  end
-end

data/app/helpers/command_tower/pagination_helper.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module CommandTower
-  module PaginationHelper
-    def pagination_values
-      (pagination_from_body || pagination_from_query || {}).compact
-    end
-
-    def pagination_from_body
-      pagination = params[:pagination]
-      return nil unless pagination.is_a?(ActionController::Parameters) || pagination.is_a?(Hash)
-
-      {
-        page: pagination_safe_integer_convert(pagination[:page]),
-        limit: pagination_safe_integer_convert(pagination[:limit]),
-        cursor: pagination_safe_integer_convert(pagination[:cursor]),
-      }
-    end
-
-    def pagination_from_query
-      return nil unless safe_boolean(value: params[:pagination]) == true
-
-      {
-        page: pagination_safe_integer_convert(params[:page]),
-        limit: pagination_safe_integer_convert(params[:limit]),
-        cursor: pagination_safe_integer_convert(params[:cursor]),
-      }
-    end
-
-    def pagination_safe_integer_convert(value, type = Integer)
-      return if value.presence.nil?
-
-      if value.to_i.to_s == value
-        value.to_i
-      else
-        nil
-      end
-    end
-  end
-end

data/app/helpers/command_tower/schema_helper.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module CommandTower
-  module SchemaHelper
-    def schema_succesful!(schema:, status:)
-      render(json: schema.to_h, status:)
-    end
-
-    def invalid_arguments!(message:, argument_object:, schema:, status:)
-      bad_arguments = argument_object.map do |key, metadata|
-        CommandTower::Schema::Error::InvalidArgument.new(
-          schema:,
-          argument: key,
-          argument_type: metadata[:type],
-          reason: metadata[:msg],
-        )
-      end
-
-      result = CommandTower::Schema::Error::InvalidArgumentResponse.new(
-        invalid_arguments: bad_arguments,
-        invalid_argument_keys: argument_object.keys,
-        status:,
-        message:,
-      )
-
-      render(json: result.to_h, status:)
-    end
-  end
-end

data/app/models/message.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-# == Schema Information
-#
-# Table name: messages
-#
-#  id               :bigint           not null, primary key
-#  pushed           :boolean          default(FALSE)
-#  text             :text(65535)
-#  title            :string(255)
-#  viewed           :boolean          default(FALSE)
-#  created_at       :datetime         not null
-#  updated_at       :datetime         not null
-#  message_blast_id :bigint
-#  user_id          :bigint           not null
-#
-# Indexes
-#
-#  index_messages_on_message_blast_id  (message_blast_id)
-#  index_messages_on_user_id           (user_id)
-#
-# Foreign Keys
-#
-#  fk_rails_...  (message_blast_id => message_blasts.id)
-#  fk_rails_...  (user_id => users.id)
-#
-class Message < ApplicationRecord
-  belongs_to :user
-  belongs_to :message_blast, optional: true
-end

data/app/models/message_blast.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-# == Schema Information
-#
-# Table name: message_blasts
-#
-#  id             :bigint           not null, primary key
-#  existing_users :boolean          default(FALSE)
-#  new_users      :boolean          default(FALSE)
-#  text           :text(65535)
-#  title          :string(255)
-#  created_at     :datetime         not null
-#  updated_at     :datetime         not null
-#  user_id        :bigint           not null
-#
-# Indexes
-#
-#  index_message_blasts_on_user_id  (user_id)
-#
-# Foreign Keys
-#
-#  fk_rails_...  (user_id => users.id)
-#
-class MessageBlast < ApplicationRecord
-  has_many :messages
-  belongs_to :user
-end

data/app/services/command_tower/admin_service/users.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-module CommandTower
-  module AdminService
-    class Users < CommandTower::ServiceBase
-      include CommandTower::PaginationServiceHelper
-
-      on_argument_validation :fail_early
-
-      # to be used for auditing later maybe?
-      validate :user, is_a: User, required: true
-
-      def call
-        schemafied_users = query.map { CommandTower::Schema::User.convert_user_object(user: _1) }
-        context.schema = CommandTower::Schema::Admin::Users.new(
-          users: schemafied_users,
-          count: schemafied_users.count,
-          pagination: pagination_schema,
-        )
-      end
-
-      def default_query
-        ::User.all.select(*CommandTower.config.user.default_attributes)
-      end
-    end
-  end
-end

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

@@ -1,23 +0,0 @@
-# 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

@@ -1,26 +0,0 @@
-# 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