neetob-ud 0.1.0

data/lib/neetob/cli/heroku/access/list.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative "../../base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module Access
+        class List < Base
+          attr_accessor :apps, :sandbox
+
+          def initialize(apps, sandbox = false)
+            super()
+            @apps = apps
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n  Users for \"#{app}\" app\n")
+              users = `heroku access -a #{app}`
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                next
+              end
+
+              ui.success(users)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/access/remove.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative "../../base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module Access
+        class Remove < Base
+          attr_accessor :apps, :users_to_be_removed, :sandbox
+
+          def initialize(apps, users_to_be_removed = [], sandbox = false)
+            super()
+            @apps = apps
+            @users_to_be_removed = users_to_be_removed
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+            matching_apps.each do |app|
+              `heroku access -a #{app}`
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                next
+              end
+
+              users_to_be_removed.each do |user|
+                ui.info(`heroku access:remove #{user} -a #{app}`)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/commands.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "config_vars/commands"
+require_relative "access/commands"
+require_relative "execute"
+
+module Neetob
+  class CLI
+    module Heroku
+      class Commands < Thor
+        desc "execute", "Run the given Heroku CLI command or Rails console command on Heroku apps"
+        option :command, type: :string, aliases: "-c", required: true, desc: "Command to run on Heroku apps"
+        option :rails, type: :boolean, aliases: "-r", default: false, desc: "Use this flag to run the given command in the Rails console"
+        option :apps, type: :array, aliases: "-a", required: true, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+        def execute
+          Execute.new(options[:apps], options[:command], options[:rails], options[:sandbox]).run
+        end
+
+        desc "config_vars", "Interact with the config(env) variables on Heroku apps"
+        subcommand "config_vars", ConfigVars::Commands
+
+        desc "access", "Interact with the users of the Heroku apps"
+        subcommand "access", Access::Commands
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/audit.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "json"
+require "terminal-table"
+
+require_relative "base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class Audit < Base
+          attr_accessor :apps, :expected_config_vars_json_file_path, :sandbox
+
+          def initialize(apps, expected_config_vars_json_file_path = "", sandbox = false)
+            super()
+            @apps = apps
+            @expected_config_vars_json_file_path = expected_config_vars_json_file_path
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+            table_rows = []
+            expected_config = read_json_file(expected_config_vars_json_file_path || default_config_vars_json_file_path)
+            return unless expected_config
+
+            matching_apps.each do |app|
+              actual_config = `heroku config -a #{app} --json`
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                next
+              end
+
+              actual_config_json = JSON.parse(actual_config)
+              table_rows.concat(compare_config_and_build_rows(app, expected_config, actual_config_json))
+            end
+            table = Terminal::Table.new headings: ["App", "Config var", "Expected", "Result"], rows: table_rows
+            ui.success(table)
+          end
+
+          private
+
+            def compare_config_and_build_rows(app, expected_config, actual_config)
+              expected_config.map do |key, val|
+                row = [app, key.to_s]
+                row << (value_set_dynamically_by_heroku?(val) ? "Heroku has dynamically set the value" : val.to_s)
+                row << (actual_config[key] == val ? "✅" : (actual_config[key] || "No such key"))
+              end
+            end
+
+            def value_set_dynamically_by_heroku?(value)
+              value == { "isDynamic" => true }
+            end
+
+            def default_config_vars_json_file_path
+              File.expand_path("../../../../../data/config-vars-audit.json", __dir__)
+            end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative "../../base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class Base < CLI::Base
+          attr_accessor :client
+
+          def initialize
+            super()
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/commands.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "thor"
+
+require_relative "list"
+require_relative "audit"
+require_relative "upsert"
+require_relative "remove"
+require_relative "../../sub_command_base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class Commands < SubCommandBase
+          desc "list", "List all the config variables in the Heroku apps"
+          option :apps, type: :array, aliases: :a, required: true, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+          option :keys, type: :array, desc: "Array of config vars that needs to be listed."
+          option :path, type: :string, desc: "The JSON file path which has config vars that needs to be listed"
+          def list
+            List.new(options[:apps], options[:keys], options[:path], options[:sandbox]).run
+          end
+
+          desc "audit", "Verify whether config vars set in Heroku apps matches against the conditions specified in JSON file."
+          option :apps, type: :array, aliases: :a, required: true, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+          option :path, type: :string, desc: "The JSON file path from which config vars will be compared"
+          def audit
+            Audit.new(options[:apps], options[:path], options[:sandbox]).run
+          end
+
+          desc "upsert", "Update and insert the config vars in Heroku apps"
+          option :apps, type: :array, aliases: :a, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+          option :path, type: :string, aliases: :p, desc: "The JSON file path from which config vars will be upserted"
+          option :path_with_project_keys, type: :string, desc: "The JSON file path with the project names as the key containing required config vars for each project."
+          def upsert
+            Upsert.new(options[:apps], options[:path], options[:path_with_project_keys], options[:sandbox]).run
+          end
+
+          desc "remove", "Remove the config vars from Heroku apps"
+          option :apps, type: :array, aliases: :a, required: true, desc: "Heroku app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web-staging\""
+          option :keys, type: :array, required: true, desc: "Array of config vars to be removed."
+          def remove
+            Remove.new(options[:apps], options[:keys], options[:sandbox]).run
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/list.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class List < Base
+          attr_accessor :apps, :sandbox, :keys, :required_config_vars_file_path
+
+          def initialize(apps, keys = [], required_config_vars_file_path = "", sandbox = false)
+            super()
+            @apps = apps
+            @sandbox = sandbox
+            @keys = keys
+            @required_config_vars_file_path = required_config_vars_file_path
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+            matching_apps.each do |app|
+              ui.info("\n  Config of #{app}\n")
+              config = `heroku config -a #{app} --json`
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                next
+              end
+              table = Terminal::Table.new headings: table_columns, rows: filter_config(config)
+              ui.success(table)
+            end
+          end
+
+          private
+
+            def table_columns
+              ["Key", "Value"]
+            end
+
+            def filter_config(config)
+              parsed_config = JSON.parse(config)
+              if keys.nil? && required_config_vars_file_path.nil?
+                return parsed_config
+              end
+
+              required_config = keys || read_json_file(required_config_vars_file_path)
+              required_config.map do |key|
+                [key, parsed_config[key]]
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/remove.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class Remove < Base
+          attr_accessor :apps, :keys, :sandbox
+
+          def initialize(apps, keys = [], sandbox = false)
+            super()
+            @apps = apps
+            @keys = keys
+            @sandbox = sandbox
+          end
+
+          def run
+            matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+            matching_apps.each do |app|
+              `heroku access -a #{app}`
+
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                next
+              end
+
+              keys.each do |key|
+                `heroku config:unset #{key} -a #{app}`
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/config_vars/upsert.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require_relative "base"
+
+module Neetob
+  class CLI
+    module Heroku
+      module ConfigVars
+        class Upsert < Base
+          attr_accessor :apps, :required_config_vars_json_file_path,
+            :required_config_vars_with_project_keys_json_file_path, :sandbox
+
+          def initialize(apps, required_config_vars_json_file_path,
+required_config_vars_with_project_keys_json_file_path, sandbox = false)
+            super()
+            @apps = apps
+            @required_config_vars_json_file_path = required_config_vars_json_file_path
+            @required_config_vars_with_project_keys_json_file_path =
+              required_config_vars_with_project_keys_json_file_path
+            @sandbox = sandbox
+          end
+
+          def run
+            check_the_given_arguments
+            inform_about_current_working_mode(sandbox) if apps.nil?
+            apps_to_be_updated = apps.nil? ?
+            read_json_file(required_config_vars_with_project_keys_json_file_path) :
+            find_all_matching_apps(apps, :heroku, sandbox)
+            inform_about_default_config_vars_file
+
+            apps_to_be_updated.each do |app|
+              required_config = apps.nil? ? app[1] : read_json_file(required_config_vars_json_file_path || default_config_vars_upsert_file_path)
+              app = app[0] if apps.nil?
+
+              if apps.nil? && sandbox && app != "neeto-dummy"
+                ui.error("The \"#{app}\" app is not available in sandbox mode.")
+                next
+              end
+
+              upsert_config_variables(app, required_config)
+            end
+          end
+
+          private
+
+            def upsert_config_variables(app, vars)
+              `heroku access -a #{app}`
+              unless $?.success?
+                ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+                ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+                return
+              end
+
+              vars.each do |key, val|
+                `heroku config:set #{key}='#{val}'  -a #{app}`
+              end
+            end
+
+            def check_the_given_arguments
+              if (!apps.nil? && !required_config_vars_with_project_keys_json_file_path.nil?) ||
+                  (apps.nil? && required_config_vars_with_project_keys_json_file_path.nil?)
+                ui.error("Please provide either apps or path to the config file with project keys")
+                exit
+              end
+            end
+
+            def default_config_vars_upsert_file_path
+              File.expand_path("../../../../../data/config-vars-upsert.json", __dir__)
+            end
+
+            def inform_about_default_config_vars_file
+              if !apps.nil? && required_config_vars_with_project_keys_json_file_path.nil? && required_config_vars_json_file_path.nil?
+                ui.info("Upserting config vars from the \"neetob/data/config-vars-upsert.json\" file")
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/heroku/execute.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Heroku
+      class Execute < Base
+        attr_accessor :apps, :command_to_execute, :should_run_in_rails_console, :sandbox
+
+        def initialize(apps, command_to_execute, should_run_in_rails_console = false, sandbox = false)
+          super()
+          @apps = apps
+          @command_to_execute = command_to_execute
+          @should_run_in_rails_console = should_run_in_rails_console
+          @sandbox = sandbox
+        end
+
+        def run
+          matching_apps = find_all_matching_apps(apps, :heroku, sandbox)
+          rails_runner_command = "heroku run rails runner '#{command_to_execute}'"
+          heroku_command = should_run_in_rails_console ? rails_runner_command : command_to_execute
+          matching_apps.each do |app|
+            ui.info("\n  Working on #{app}\n")
+            output = `#{heroku_command} -a #{app}`
+            unless $?.success?
+              ui.error("There is a problem in accessing the app with name \"#{app}\" in your account.")
+              ui.error("Please check the specified app name and ensure you're authorized to view that app.")
+              next
+            end
+            ui.success(output)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/local/commands.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "thor"
+require_relative "ls"
+
+module Neetob
+  class CLI
+    module Local
+      class Commands < Thor
+        desc "ls", "List the files in local neeto repos"
+        option :apps, type: :array, aliases: "-a", required: true, desc: "Neeto app names. Can be matched using the '*' wildcard. Example: \"neeto*\" \"neeto-cal-web\""
+        option :dir, type: :string, aliases: "-d", desc: "Mention the directory you want to list"
+        def ls
+          Ls.new(options[:apps], options[:dir], options[:sandbox]).run
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/local/ls.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Local
+      class Ls < Base
+        attr_accessor :sandbox, :apps, :dir
+
+        def initialize(apps, dir, sandbox = false)
+          super()
+          @apps = apps
+          @dir = dir
+          @sandbox = sandbox
+        end
+
+        def run
+          matching_apps = find_all_matching_apps(apps, :github, sandbox, true)
+          matching_apps.each do |app|
+            app_name = app.split("/")[1]
+            ui.info("\nListing files from #{app_name}/#{dir}\n")
+            ui.info(`cd ./#{app_name} && ls #{dir}`)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/neetob/cli/sub_command_base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "thor"
+
+class SubCommandBase < Thor
+  def self.banner(command, namespace = nil, subcommand = false)
+    "#{basename} #{subcommand_prefix} #{command.usage}"
+  end
+
+  def self.subcommand_prefix
+    self.name
+      .split("::")[2..-2]
+      .map { |name| name.gsub(%r{^[A-Z]}) { |match| match[0].downcase } }
+      .map { |name| name.gsub(%r{[A-Z]}) { |match| "-#{match[0].downcase}" } }
+      .join(" ")
+  end
+end

data/lib/neetob/cli/ui.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+4# frozen_string_literal: true
+
+require "thor"
+
+module Neetob
+  class CLI
+    class UI
+      attr_accessor :shell
+
+      def initialize
+        @shell = Thor::Base.shell.new
+      end
+
+      def say(statement, color = Thor::Shell::Color::YELLOW)
+        shell.say(statement, color)
+      end
+
+      def ask(question, echo = true)
+        shell.ask(question, echo: echo)
+      end
+
+      def yes?(question)
+        shell.yes?(question)
+      end
+
+      def error(statement)
+        shell.say(statement, Thor::Shell::Color::RED)
+      end
+
+      def success(statement)
+        shell.say(statement, Thor::Shell::Color::GREEN)
+      end
+
+      def info(statement)
+        shell.say(statement)
+      end
+    end
+  end
+end

data/lib/neetob/cli/users/audit.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Neetob
+  class CLI
+    module Users
+      class Audit < Base
+        attr_accessor :sandbox
+
+        def initialize(sandbox = false)
+          super()
+          @sandbox = sandbox
+        end
+
+        def run
+          users_data = users_for_all_available_apps
+          users = extract_values_from_user_data(users_data)
+          email_repos_map = create_email_repos_map(users)
+          unique_users = users.uniq { |user| [user[0], user[1]] }.sort
+          ui.info("\nUsers with multiple emails:")
+          find_users_with_multiple_emails(unique_users.transpose, email_repos_map)
+          ui.info("Users with emails having 3rd party domains:")
+          find_users_with_invalid_emails(unique_users.transpose, email_repos_map)
+        end
+
+        private
+
+          def users_for_all_available_apps
+            find_all_matching_apps(["*"], :github, sandbox, true).map do |app|
+              clone_repo_and_get_users(app).split("\n").map { |user| "#{user} #{app}" }
+            end
+          end
+
+          def extract_values_from_user_data(users)
+            users.flatten.map do |user|
+              values = user.strip.split(" ")[1..-1]
+              [values[0..-3].join(" "), clean_email(values[-2]), clean_repo_name(values[-1])]
+            end
+          end
+
+          def clone_repo_and_get_users(app)
+            app_name_without_org_suffix = app.split("/")[1]
+            `git -C ./#{app_name_without_org_suffix} shortlog -sne`
+          end
+
+          def create_email_repos_map(users)
+            map = {}
+            users.each do |user|
+              email = user[1]
+              repo = user[2]
+              map[email] = [] unless map.key?(email)
+              map[email].push(repo)
+            end
+            map
+          end
+
+          def find_users_with_multiple_emails(users, email_repos_map)
+            user_emails = {}
+            users[0].each_with_index do |name, index|
+              email = users[1][index]
+              user_emails[name] = [] unless user_emails.key?(name)
+              user_emails[name].push(email)
+            end
+            user_with_multiple_emails = user_emails.filter { |_, val| val.length > 1 }
+            table_rows = create_rows_and_add_repos(user_with_multiple_emails, email_repos_map)
+            create_and_show_table(table_rows, table_columns)
+          end
+
+          def find_users_with_invalid_emails(users, email_repos_map)
+            user_with_invalid_emails = {}
+            users[1].each_with_index do |email, index|
+              name = users[0][index]
+              if invalid_email?(email)
+                user_with_invalid_emails[name] = [] unless user_with_invalid_emails.key?(name)
+                user_with_invalid_emails[name].push(email)
+              end
+            end
+            table_rows = create_rows_and_add_repos(user_with_invalid_emails, email_repos_map)
+            create_and_show_table(table_rows, table_columns)
+          end
+
+          def table_columns
+            [:Name, :Email, :Repo]
+          end
+
+          def create_rows_and_add_repos(users, email_repos_map)
+            users.map do |name, emails|
+              repos = emails.map { |email| email_repos_map[email] }
+              [name, emails.join(", "), join_and_truncate_repos(repos)]
+            end
+          end
+
+          def create_and_show_table(data, column_names)
+            table = Terminal::Table.new headings: column_names, rows: data
+            ui.error(table)
+          end
+
+          def join_and_truncate_repos(repos)
+            repos.flatten.uniq.join(",").truncate(35)
+          end
+
+          def clean_email(email)
+            email.gsub(/<|>/, "")
+          end
+
+          def clean_repo_name(repo)
+            repo.gsub("bigbinary/", "")
+          end
+
+          def invalid_email?(email)
+            !allowed_email_domains.any? { |domain| email.downcase.include?(domain) }
+          end
+
+          def allowed_email_domains
+            ["github", "gmail", "bigbinary"]
+          end
+      end
+    end
+  end
+end