pcli 0.1.0

data/lib/pcli/services/all_commands.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    class AllCommands
+      include Depends.on(
+        user_show: 'commands.user.show',
+        user_change: 'commands.user.change',
+        user_password: 'commands.user.password',
+        user_totp: 'commands.user.totp',
+        users_list: 'commands.users.list',
+        users_create: 'commands.users.create',
+        users_change: 'commands.users.change',
+        users_remove: 'commands.users.remove',
+        templates_list: 'commands.templates.list',
+        templates_change: 'commands.templates.change',
+        login: 'commands.login',
+        logout: 'commands.logout',
+      )
+
+      def registry
+        me = self
+
+        Module.new do
+          extend Dry::CLI::Registry
+
+          register 'user', aliases: %w[me myself profile] do |p|
+            p.register 'show', me.user_show, aliases: %w[sh view]
+            p.register 'change', me.user_change, aliases: %w[ch chng update up modify mod]
+            p.register 'password', me.user_password, aliases: %w[passwd pass pwd pw]
+            p.register 'totp', me.user_totp, aliases: %w[code otp]
+          end
+
+          register 'users', aliases: %w[admins u] do |p|
+            p.register 'list', me.users_list, aliases: %w[l all index]
+            p.register 'change', me.users_change, aliases: %w[ch chng update up modify mod]
+            p.register 'create', me.users_create, aliases: %w[make new n]
+            p.register 'remove', me.users_remove, aliases: %w[rem r delete del d destroy]
+          end
+
+          register 'templates', aliases: %w[temps temp tmp t] do |p|
+            p.register 'list', me.templates_list, aliases: %w[l all index]
+            p.register 'change', me.templates_change, aliases: %w[ch chng update up modify mod]
+          end
+
+          register 'login', me.login, aliases: %w[signin authenticate auth]
+          register 'logout', me.logout, aliases: %w[signout deauthenticate deauth unauthenticate unauth]
+        end
+      end
+    end
+  end
+end

data/lib/pcli/services/all_steps.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    class AllSteps
+      include Depends.on(
+        'steps.greeting',
+        'steps.connect',
+        'steps.main',
+        'steps.valediction'
+      )
+
+      def all
+        [
+          greeting,
+          connect,
+          main,
+          valediction
+        ]
+      end
+    end
+  end
+end

data/lib/pcli/services/api.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    class Api
+      include Depends.on('client')
+      attr_accessor :token
+
+      def send(request)
+        client.send(request)
+      end
+
+      def info
+        send ApiRequest.new('info')
+      end
+
+      def auth(username, password, totp)
+        send ApiRequest.new('admin/auth')
+                       .method(:post)
+                       .params(
+                         username: username,
+                         password: password,
+                         totp: totp
+                       )
+      end
+
+      def me
+        send authenticated(ApiRequest.new('admin/me'))
+      end
+
+      def change_me(payload)
+        send authenticated(ApiRequest.new('admin/me')
+          .method(:patch)
+          .params(payload))
+      end
+
+      def rotate_password
+        send authenticated(ApiRequest.new('admin/me/password').method(:post))
+      end
+
+      def rotate_totp
+        send authenticated(ApiRequest.new('admin/me/totp').method(:post))
+      end
+
+      def users
+        send authenticated(ApiRequest.new('admin/admins'))
+      end
+
+      def change_user(id, payload)
+        send authenticated(ApiRequest.new("admin/admins/#{id}"))
+          .method(:patch)
+          .params(payload)
+      end
+
+      def create_user(payload)
+        send authenticated(ApiRequest.new('admin/admins'))
+          .method(:post)
+          .params(payload)
+      end
+
+      def remove_user(id)
+        send authenticated(ApiRequest.new("admin/admins/#{id}")).method(:delete)
+      end
+
+      def templates
+        send authenticated(ApiRequest.new('admin/templates'))
+      end
+
+      def change_template(id, payload)
+        send authenticated(ApiRequest.new("admin/templates/#{id}"))
+          .method(:patch)
+          .params(payload)
+      end
+
+      private
+
+      def authenticated(request)
+        request.header('Authorization', "Bearer #{token}")
+      end
+    end
+  end
+end

data/lib/pcli/services/api_manager.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    class ApiManager
+      include Depends.on('output', 'authenticate', 'api')
+
+      def ensure_authenticated(&block)
+        unless api.token
+          return ensure_authenticated(&block) if authenticate.run(true)
+        end
+
+        response = block.call
+
+        return if response === false
+
+        if response.failure? && response.known_error? && response.error.type == 'unauthenticated'
+          output.puts
+          output.puts(Pl.dim("You've been logged out. Please log in again."))
+          output.puts
+          return ensure_authenticated(&block) if authenticate.run(false)
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/pcli/services/app.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    class App
+      include Depends.on(
+        'output',
+        steps: 'all_steps'
+      )
+
+      def run
+        result = nil
+        prev_space = false
+        steps.all.each.with_index do |step, i|
+          break if result&.halt? && !step.ensured?
+
+          output.puts if i.positive? && step.spaced? && !prev_space
+
+          result = step.run(result)
+
+          if i < steps.all.count - 1 && step.spaced?
+            prev_space = true
+            output.puts
+          else
+            prev_space = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pcli/services/authenticate.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    class Authenticate
+      include ActionView::Helpers::DateHelper
+
+      include Depends.on(
+        'output', 'prompt', 'api', 'screen'
+      )
+
+      def run(should_prompt = true)
+        if should_prompt
+          output.puts Pl.dim('Please login.')
+          output.puts
+        end
+
+        username = prompt.ask('Username:')
+        password = prompt.mask('Password:')
+        totp = prompt.ask('TOTP Code:')
+        output.puts
+
+        spinner = SimpleSpinnerBar.start('Authenticating...', output)
+        response = api.auth(username, password, totp)
+
+        if response.success?
+          api.token = response.json['token']
+          expires_at = DateTime.parse(response.json['expiresAt'])
+          time = distance_of_time_in_words(DateTime.now, expires_at)
+
+          spinner.success("#{Pl.green('Authenticated')} for the next #{Pl.yellow(time)}")
+          true
+        else
+          spinner.failure
+
+          output.puts
+          if response.known_error?
+            if response.error.type == 'invalid_credentials'
+              output.puts Pl.yellow('Invalid credentials!')
+              output.puts
+              return run(false)
+            end
+
+            puts 'Server:'
+            Output::Padded.show([
+                                  "#{Pl.yellow(response.error.title)} #{Pl.dim("(#{response.error.status})")}",
+                                  '',
+                                  response.error.message
+                                ], output, screen)
+          else
+            output.puts "Server #{Pl.yellow("(#{response.code})")}:"
+            output.puts Output::Padded.show(response.body, output, screen)
+          end
+
+          false
+        end
+      end
+    end
+  end
+end

data/lib/pcli/services/client.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    class Client
+      include Depends.on('config.endpoint')
+
+      def send(request)
+        r = HTTP.send(
+          request.method,
+          URI.join(endpoint, request.path),
+          body: request.params.to_json,
+          headers: request.headers
+        )
+        ApiResponse.new(
+          r.code,
+          r.status.success?,
+          r.status.reason,
+          r.to_s
+        )
+      end
+    end
+  end
+end

data/lib/pcli/services/cmd.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    class Cmd
+      include Depends.on('output')
+
+      def new(**options)
+        TTY::Command.new(output: output, **options)
+      end
+    end
+  end
+end

data/lib/pcli/services/commander.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Dry
+  class CLI
+    def exit(code); end
+
+    def perform_registry(arguments)
+      result = registry.get(arguments)
+      return usage(result) unless result.found?
+
+      command, args = parse(result.command, result.arguments, result.names)
+
+      result.before_callbacks.run(command, args)
+      output = command.call(**args)
+      result.after_callbacks.run(command, args)
+
+      output
+    end
+  end
+end
+
+module Pcli
+  module Services
+    class Commander
+      include Depends.on('output', commands: 'all_commands')
+
+      def initialize(**args)
+        super
+
+        @cli = Dry::CLI.new(commands.registry)
+      end
+
+      def run(cmd)
+        @cli.call(arguments: cmd.split, out: output, err: output)
+      end
+    end
+  end
+end

data/lib/pcli/services/commands/login.rb

@@ -0,0 +1,22 @@
+module Pcli
+  module Services
+    module Commands
+      class Login < Dry::CLI::Command
+        include Depends.on('authenticate', 'api', 'prompt', 'output')
+
+        desc 'Log in.'
+
+        def call(*)
+          if api.token && !prompt.yes?('You are already logged in. Would you like to log out?')
+            output.puts('Aborted.')
+            return
+          end
+
+          authenticate.run(true)
+
+          CommandOutput.continue
+        end
+      end
+    end
+  end
+end

data/lib/pcli/services/commands/logout.rb

@@ -0,0 +1,24 @@
+module Pcli
+  module Services
+    module Commands
+      class Logout < Dry::CLI::Command
+        include Depends.on('authenticate', 'api', 'output')
+
+        desc 'Log out.'
+
+        def call(*)
+          unless api.token
+            output.puts('You are not logged in.')
+            return
+          end
+
+          api.token = nil
+
+          output.puts(Pl.green('Logged out.'))
+
+          CommandOutput.continue
+        end
+      end
+    end
+  end
+end

data/lib/pcli/services/commands/templates/change.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    module Commands
+      module Templates
+        class Change < Dry::CLI::Command
+          include Depends.on(
+            'api',
+            'api_manager',
+            'output',
+            'screen',
+            'editor',
+            'prompt'
+          )
+
+          desc 'Change or view a template.'
+
+          argument :template, desc: 'The template id to change.'
+
+          def call(template: nil, **args)
+            response = api_manager.ensure_authenticated do
+              spinner = SimpleSpinnerBar.start('Retrieving templates...', output)
+              r = api.templates
+              if r.failure?
+                spinner.failure
+              else
+                spinner.success
+              end
+              r
+            end
+
+            if response.failure?
+              output.puts
+              Output::ServerError.show(response, output, screen)
+            end
+
+            templates = response.json
+
+            unless template
+              choices = templates.map { |t| { name: "#{t['name']} (#{t['id']})", value: t['id'] } }
+              template = prompt.select('Which template would you like to view/change?', choices)
+            end
+
+            template = templates.find { |t| t['id'] === template }
+            unless template
+              output.puts(Pl.yellow('That template does not exist.'))
+              return CommandOutput.continue
+            end
+
+            file = Tempfile.new('pcli_open_template')
+            file.write(template['templateXML'])
+            file.close
+
+            unless editor.open(file.path)
+              output.puts('Aborted.')
+              return CommandOutput.continue
+            end
+
+            file.open
+            new_template = file.read
+
+            if template['templateXML'] == new_template
+              output.puts('Nothing to change.')
+              return CommandOutput.continue
+            end
+
+            unless prompt.yes?('Save changes?')
+              output.puts('Aborted.')
+              return CommandOutput.continue
+            end
+
+            response = api_manager.ensure_authenticated do
+              spinner = SimpleSpinnerBar.start('Changing template...', output)
+              r = api.change_template(template['id'], { 'templateXML' => new_template })
+              if r.failure?
+                spinner.failure
+              else
+              spinner.success("Template #{Pl.green('changed')}")
+              end
+              r
+            end
+
+            if response.failure?
+              output.puts
+              Output::ServerError.show(response, output, screen)
+            end
+
+            CommandOutput.continue
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pcli/services/commands/templates/list.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    module Commands
+      module Templates
+        class List < Dry::CLI::Command
+          include Depends.on(
+            'api',
+            'api_manager',
+            'output',
+            'screen'
+          )
+
+          desc 'Get a list of all templates.'
+
+          def call(*)
+            spinner = nil
+            response = api_manager.ensure_authenticated do
+              spinner = SimpleSpinnerBar.start('Retrieving templates...', output)
+              r = api.templates
+              if r.failure?
+                spinner.failure
+              else
+                spinner.success
+              end
+              r
+            end
+
+            if response.success?
+              spinner.success
+              output.puts
+              output.puts TTY::Table.new(
+                header: [
+                  Pl.bold('ID'), Pl.bold('Name')
+                ],
+                rows: response.json.map { |u| [u['id'], u['name']] }
+              ).render(:ascii)
+            else
+              spinner.failure
+
+              output.puts
+              Output::ServerError.show(response, output, screen)
+            end
+
+            CommandOutput.continue
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pcli/services/commands/user/change.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Pcli
+  module Services
+    module Commands
+      module User
+        class Change < Dry::CLI::Command
+          @field_options = []
+
+          class << self
+            attr_reader :field_options
+
+            def field_option(name, *args, **kw_args)
+              @field_options << name
+              option name, *args, **kw_args
+            end
+          end
+
+          include Depends.on(
+            'api_manager',
+            'api',
+            'output',
+            'screen',
+            'prompt'
+          )
+
+          desc 'Change name or username of the logged-in administrator.'
+
+          field_option :name, type: :boolean, default: nil, desc: 'Whether to change the name'
+          field_option :username, type: :boolean, default: nil, desc: 'Whether to change the username'
+          option :all, type: :boolean, default: false, desc: 'Change all fields'
+
+          def call(all:, **args)
+            field_args = args.slice(*self.class.field_options)
+
+            response = api_manager.ensure_authenticated do
+              spinner = SimpleSpinnerBar.start('Retrieving user...', output)
+              r = api.me
+              if r.failure?
+                spinner.failure
+              else
+                spinner.success
+              end
+              r
+            end
+
+            if response.success?
+              spinner.success
+            else
+              spinner.failure
+
+              output.puts
+              Output::ServerError.show(response, output, screen)
+            end
+
+            fields = nil
+
+            if all == false && field_args.empty?
+              fields = prompt
+                       .multi_select('Which fields do you want to change?', self.class.field_options)
+                       .map { |n| [n, true] }
+                       .to_h
+            else
+              begin
+                fields = Util::Cli.analyze_fields_flags(all, self.class.field_options, field_args)
+              rescue Util::Cli::FieldsFlagsError => e
+                output.puts Pl.yellow(e.message)
+                return CommandOutput.continue
+              end
+            end
+
+            payload = {}
+
+            if fields[:name]
+              name = prompt.ask('Name', default: response.json['name'])
+              payload['name'] = name if name != response.json['name']
+            end
+
+            if fields[:username]
+              username = prompt.ask('Username', default: response.json['username'])
+              payload['username'] = username if username != response.json['username']
+            end
+
+            if payload.empty?
+              output.puts Pl.yellow('Nothing to change!')
+              return CommandOutput.continue
+            end
+
+            spinner = SimpleSpinnerBar.start('Changing user...', output)
+            response = api_manager.ensure_authenticated { api.change_me(payload) }
+
+            if response.success?
+              spinner.success("User #{Pl.green('changed')}")
+
+              output.puts
+              output.puts TTY::Table.new(rows: [
+                                           [Pl.bold('ID'), response.json['id']],
+                                           [Pl.bold('Name'), response.json['name']],
+                                           [Pl.bold('Username'), response.json['username']]
+                                         ]).render(:ascii)
+            else
+              spinner.failure
+
+              output.puts
+              Output::ServerError.show(response, output, screen)
+            end
+
+            CommandOutput.continue
+          end
+        end
+      end
+    end
+  end
+end