postfix_admin 0.2.1 → 0.3.1

data/lib/postfix_admin/cli.rb

@@ -1,6 +1,7 @@
 require 'yaml'
 require 'postfix_admin'
 require 'postfix_admin/doveadm'
+require 'terminal-table'
 
 module PostfixAdmin
   class CLI
@@ -29,127 +30,142 @@ module PostfixAdmin
       name = name.downcase if name
 
       if name =~ /@/
+        # address like argument
         if Admin.exists?(name)
-          show_admin_details(name)
-        end
-
-        if Mailbox.exists?(name)
-          show_account_details(name)
+          # admin
+          show_admin_details(name, display_password: true)
+          puts
+          show_admin_domain(name)
+        elsif Mailbox.exists?(name)
+          # mailbox
+          show_account_details(name, display_password: true)
         elsif Alias.exists?(name)
+          # alias
           show_alias_details(name)
+        else
+          raise Error, "Could not find admin/mailbox/alias #{name}"
         end
 
         return
       end
 
       show_summary(name)
+      puts
 
       if name
-        show_admin(name)
-        show_address(name)
-        show_alias(name)
+        # domain name
+        show_domain_details(name)
       else
-        show_domain
-        show_admin
+        # no argument: show all domains and admins
+        show_domains
+        puts
+        show_admins
       end
     end
 
     def show_summary(domain_name = nil)
-      title = "Summary"
       if domain_name
-        domain_name = domain_name.downcase
-        domain_check(domain_name)
-        title = "Summary of #{domain_name}"
-      end
-
-      report(title) do
-        if domain_name
-          domain = Domain.find(domain_name)
-          puts "Mailboxes : %4d / %4s"    % [domain.rel_mailboxes.count, max_str(domain.mailboxes)]
-          puts "Aliases   : %4d / %4s"    % [domain.pure_aliases.count, max_str(domain.aliases)]
-          puts "Max Quota : %4d MB" % domain.maxquota
-          puts "Active    :  %3s" % domain.active_str
-        else
-          puts "Domains   : %4d" % Domain.without_all.count
-          puts "Admins    : %4d" % Admin.count
-          puts "Mailboxes : %4d" % Mailbox.count
-          puts "Aliases   : %4d" % Alias.pure.count
-        end
+        show_domain_summary(domain_name)
+      else
+        show_general_summary
       end
     end
 
-    def setup_domain(domain_name, password)
+    # Set up a domain
+    # Add a domain, add an admin, and grant the admin access to the domain
+    def setup_domain(domain_name, password, scheme: nil, rounds: nil)
       admin = "admin@#{domain_name}"
       add_domain(domain_name)
-      add_admin(admin, password)
+      add_admin(admin, password, scheme: scheme, rounds: rounds)
       add_admin_domain(admin, domain_name)
     end
 
-    def show_account_details(user_name)
+    # Tear down a domain
+    # Delete a domain and delete an admin user for it
+    def teardown_domain(domain_name)
+      admin = "admin@#{domain_name}"
+      delete_domain(domain_name)
+      delete_admin(admin)
+    end
+
+    def show_account_details(user_name, display_password: false)
       account_check(user_name)
       mailbox    = Mailbox.find(user_name)
       mail_alias = Alias.find(user_name)
 
-      report("Mailbox") do
-        puts "Address  : %s" % mailbox.username
-        puts "Name     : %s" % mailbox.name
-        puts "Password : %s" % mailbox.password
-        puts "Quota    : %d MB" % max_str(mailbox.quota / KB_TO_MB)
-        puts "Go to    : %s" % mail_alias.goto
-        puts "Active   : %s" % mailbox.active_str
-      end
+      rows = []
+      puts_title("Mailbox")
+      rows << ["Address", mailbox.username]
+      rows << ["Name", mailbox.name]
+      rows << ["Password", mailbox.password] if display_password
+      rows << ["Quota (MB)", mailbox.quota_display_str(format: "%.1f")]
+      rows << ["Go to", mail_alias.goto]
+      rows << ["Active", mailbox.active_str]
+
+      puts_table(rows: rows)
     end
 
-    def show_admin_details(name)
+    def show_admin_details(name, display_password: false)
       admin_check(name)
       admin = Admin.find(name)
 
-      report("Admin") do
-        puts "Name     : %s" % admin.username
-        puts "Password : %s" % admin.password
-        puts "Domains  : %s" % (admin.super_admin? ? "ALL" : admin.rel_domains.count)
-        puts "Role     : %s" % (admin.super_admin? ? "Super admin" : "Admin")
-        puts "Active   : %s" % admin.active_str
-      end
+      rows = []
+      puts_title("Admin")
+      rows << ["Name", admin.username]
+      rows << ["Password", admin.password] if display_password
+      rows << ["Domains", admin.super_admin? ? "ALL" : admin.rel_domains.count.to_s]
+      rows << ["Role", admin.super_admin? ? "Super Admin" : "Standard Admin"]
+      rows << ["Active", admin.active_str]
+
+      puts_table(rows: rows)
     end
 
     def show_alias_details(name)
       alias_check(name)
       mail_alias = Alias.find(name)
-      report("Alias") do
-        puts "Address  : %s" % mail_alias.address
-        puts "Go to    : %s" % mail_alias.goto
-        puts "Active   : %s" % mail_alias.active_str
-      end
+
+      rows = []
+      puts_title("Alias")
+      rows << ["Address", mail_alias.address]
+      rows << ["Go to", mail_alias.goto]
+      rows << ["Active", mail_alias.active_str]
+
+      puts_table(rows: rows)
     end
 
-    def show_domain
-      index = " No. Domain                          Aliases   Mailboxes     Quota (MB)  Active"
-      report('Domains', index) do
-        if Domain.without_all.empty?
-          puts " No domains"
-          next
-        end
+    def show_domains
+      rows = []
+      headings = ["No.", "Domain", "Aliases", "Mailboxes","Max Quota (MB)",
+                  "Active", "Description"]
 
-        Domain.without_all.each_with_index do |d, i|
-          puts "%4d %-30s %3d /%3s   %3d /%3s %10d         %-3s" %
-            [i+1, d.domain, d.pure_aliases.count, max_str(d.aliases),
-             d.rel_mailboxes.count, max_str(d.mailboxes), d.maxquota, d.active_str]
-        end
+      puts_title("Domains")
+      if Domain.without_all.empty?
+        puts "No domains"
+        return
+      end
+
+      Domain.without_all.each_with_index do |d, i|
+        no = i + 1
+        aliases_str = "%4d / %4s" % [d.pure_aliases.count, d.aliases_str]
+        mailboxes_str = "%4d / %4s" % [d.rel_mailboxes.count, d.mailboxes_str]
+        rows << [no.to_s, d.domain, aliases_str, mailboxes_str,
+                 d.maxquota_str, d.active_str, d.description]
       end
+
+      puts_table(headings: headings, rows: rows)
     end
 
-    def add_domain(domain_name)
-      @base.add_domain(domain_name)
+    def add_domain(domain_name, description: nil)
+      @base.add_domain(domain_name, description: description)
       puts_registered(domain_name, "a domain")
     end
 
-    def change_admin_password(user_name, password)
-      change_password(Admin, user_name, password)
+    def change_admin_password(user_name, password, scheme: nil, rounds: nil)
+      change_password(Admin, user_name, password, scheme: scheme, rounds: rounds)
     end
 
-    def change_account_password(user_name, password)
-      change_password(Mailbox, user_name, password)
+    def change_account_password(user_name, password, scheme: nil, rounds: nil)
+      change_password(Mailbox, user_name, password, scheme: scheme, rounds: rounds)
     end
 
     def edit_admin(admin_name, options)
@@ -163,7 +179,7 @@ module PostfixAdmin
       admin.active = options[:active] unless options[:active].nil?
       admin.save!
 
-      puts "Successfully updated #{admin_name}"
+      puts "successfully updated #{admin_name}"
       show_admin_details(admin_name)
     end
 
@@ -174,9 +190,10 @@ module PostfixAdmin
       domain.mailboxes = options[:mailboxes] if options[:mailboxes]
       domain.maxquota     = options[:maxquota]  if options[:maxquota]
       domain.active       = options[:active] unless options[:active].nil?
+      domain.description  = options[:description] if options[:description]
       domain.save!
 
-      puts "Successfully updated #{domain_name}"
+      puts "successfully updated #{domain_name}"
       show_summary(domain_name)
     end
 
@@ -185,71 +202,101 @@ module PostfixAdmin
       puts_deleted(domain_name)
     end
 
-    def show_admin(domain_name = nil)
+    def show_admins(domain_name = nil)
       admins = domain_name ? Admin.select { |a| a.rel_domains.exists?(domain_name) } : Admin.all
-      index = " No. Admin                                        Domains Active"
-      report("Admins", index) do
-        if admins.empty?
-          puts " No admins"
-          next
-        end
+      headings = ["No.", "Admin", "Domains", "Active", "Scheme Prefix"]
 
-        admins.each_with_index do |a, i|
-          domains = a.super_admin? ? 'Super admin' : a.rel_domains.count
-          puts "%4d %-40s %11s   %-3s" % [i+1, a.username, domains, a.active_str]
-        end
+      puts_title("Admins")
+      if admins.empty?
+        puts "No admins"
+        return
+      end
+
+      rows = []
+      admins.each_with_index do |a, i|
+        no = i + 1
+        domains = a.super_admin? ? 'Super Admin' : a.rel_domains.count
+        rows << [no.to_s, a.username, domains.to_s, a.active_str, a.scheme_prefix]
       end
+
+      puts_table(headings: headings, rows: rows)
     end
 
-    def show_address(domain_name)
-      domain_check(domain_name)
+    def show_accounts(domain_name=nil)
+      domain_check(domain_name) if domain_name
 
-      mailboxes = Domain.find(domain_name).rel_mailboxes
-      index = " No. Email                           Name                 Quota (MB) Active         Maildir"
-      report("Addresses", index) do
-        if mailboxes.empty?
-          puts " No addresses"
-          next
-        end
+      rows = []
+      mailboxes = if domain_name
+                    Domain.find(domain_name).rel_mailboxes
+                  else
+                    Mailbox.all
+                  end
+      headings = ["No.", "Email", "Name", "Quota (MB)", "Active",
+                  "Scheme Prefix", "Maildir"]
 
-        mailboxes.each_with_index do |m, i|
-          quota = m.quota.to_f/ KB_TO_MB.to_f
-          puts "%4d %-30s  %-20s %10s   %-3s  %s" % [i+1, m.username, m.name, max_str(quota.to_i), m.active_str, m.maildir]
-        end
+      puts_title("Accounts")
+      if mailboxes.empty?
+        puts "No accounts"
+        return
       end
-    end
 
-    def show_alias(domain_name)
-      domain_check(domain_name)
+      mailboxes.each_with_index do |m, i|
+        no = i + 1
+        rows << [no.to_s, m.username, m.name, m.quota_display_str,
+                 m.active_str, m.scheme_prefix, m.maildir]
+      end
+
+      puts_table(headings: headings, rows: rows)
+    end
 
-      forwards, aliases = Domain.find(domain_name).rel_aliases.partition { |a| a.mailbox? }
+    def show_forwards(domain_name=nil)
+      domain_check(domain_name) if domain_name
 
-      forwards.delete_if do |f|
-        f.address == f.goto
-      end
+      forwards = if domain_name
+                   Domain.find(domain_name).rel_aliases.forward
+                 else
+                   Alias.forward
+                 end
 
       show_alias_base("Forwards", forwards)
+    end
+
+    def show_aliases(domain_name=nil)
+      domain_check(domain_name) if domain_name
+
+      aliases = if domain_name
+                  Domain.find(domain_name).rel_aliases.pure
+                else
+                  db_aliases = Alias.pure
+                end
+
       show_alias_base("Aliases",  aliases)
     end
 
     def show_admin_domain(user_name)
       admin = Admin.find(user_name)
+      puts_title("Admin Domains (#{user_name})")
       if admin.rel_domains.empty?
-        puts "\nNo domain in database"
+        puts "\nNo domains for #{user_name}"
         return
       end
 
-      report("Domains (#{user_name})", " No. Domain") do
-        admin.rel_domains.each_with_index do |d, i|
-          puts "%4d %-30s" % [i + 1, d.domain]
-        end
+      rows = []
+      admin.rel_domains.each_with_index do |d, i|
+        no = i + 1
+        rows << [no.to_s, d.domain]
       end
+      puts_table(rows: rows, headings: %w[No. Domain])
     end
 
-    def add_admin(user_name, password, super_admin = false, scheme = nil)
+    def add_admin(user_name, password, super_admin: false,
+                  scheme: nil, rounds: nil)
       validate_password(password)
 
-      @base.add_admin(user_name, hashed_password(password, scheme))
+      h_password = hashed_password(password, user_name: user_name,
+                                   scheme: scheme, rounds: rounds)
+      @base.add_admin(user_name, h_password)
+
       if super_admin
         Admin.find(user_name).super_admin = true
         puts_registered(user_name, "a super admin")
@@ -268,12 +315,13 @@ module PostfixAdmin
       puts "#{domain_name} was successfully deleted from #{user_name}"
     end
 
-    def add_account(address, password, scheme = nil, name = nil)
+    def add_account(address, password, name: nil, scheme: nil, rounds: nil)
       validate_password(password)
 
-      @base.add_account(address, hashed_password(password, scheme), name)
+      h_password = hashed_password(password, user_name: address,
+                                   scheme: scheme, rounds: rounds)
+      @base.add_account(address, h_password, name: name)
       puts_registered(address, "an account")
-      show_account_details(address)
     end
 
     def add_alias(address, goto)
@@ -282,10 +330,13 @@ module PostfixAdmin
     end
 
     def edit_account(address, options)
+      quota = options[:quota]
+      raise "Invalid Quota value: #{quota}" if quota && quota <= 0
+
       mailbox_check(address)
       mailbox = Mailbox.find(address)
       mailbox.name = options[:name] if options[:name]
-      mailbox.quota = options[:quota] * KB_TO_MB if options[:quota]
+      mailbox.quota_mb = quota if quota
       mailbox.active = options[:active] unless options[:active].nil?
       mailbox.save!
 
@@ -295,7 +346,7 @@ module PostfixAdmin
         mail_alias.save!
       end
 
-      puts "Successfully updated #{address}"
+      puts "successfully updated #{address}"
       show_account_details(address)
     end
 
@@ -306,7 +357,7 @@ module PostfixAdmin
       mail_alias.active = options[:active] unless options[:active].nil?
       mail_alias.save or raise "Could not save Alias"
 
-      puts "Successfully updated #{address}"
+      puts "successfully updated #{address}"
       show_alias_details(address)
     end
 
@@ -325,11 +376,25 @@ module PostfixAdmin
       puts_deleted(address)
     end
 
-    def log
-      Log.all.each do |l|
-        time = l.timestamp.strftime("%Y-%m-%d %X %Z")
-        puts "#{time}  #{l.username}  #{l.domain}  #{l.action}  #{l.data}"
+    def log(domain: nil, last: nil)
+      headings = %w[Timestamp Admin Domain Action Data]
+      rows = []
+
+      logs = if domain
+               Log.where(domain: domain)
+             else
+               Log.all
+             end
+
+      logs = logs.last(last) if last
+
+      logs.each do |l|
+        # TODO: Consider if zone should be included ('%Z').
+        time = l.timestamp.strftime("%Y-%m-%d %X")
+        rows << [time, l.username, l.domain, l.action, l.data]
       end
+
+      puts_table(headings: headings, rows: rows)
     end
 
     def dump
@@ -366,17 +431,60 @@ module PostfixAdmin
 
     private
 
+    def show_general_summary
+      rows = []
+      title = "Summary"
+      rows << ["Domains", Domain.without_all.count]
+      rows << ["Admins", Admin.count]
+      rows << ["Mailboxes", Mailbox.count]
+      rows << ["Aliases", Alias.pure.count]
+
+      puts_title(title)
+      puts_table(rows: rows)
+    end
+
+    def show_domain_summary(domain_name)
+      domain_name = domain_name.downcase
+      domain_check(domain_name)
+
+      rows = []
+      domain = Domain.find(domain_name)
+      rows << ["Mailboxes", "%4d / %4s" % [domain.rel_mailboxes.count, domain.mailboxes_str]]
+      rows << ["Aliases", "%4d / %4s" % [domain.pure_aliases.count, domain.aliases_str]]
+      rows << ["Max Quota (MB)", domain.maxquota_str]
+      rows << ["Active", domain.active_str]
+      rows << ["Description", domain.description]
+
+      puts_title(domain_name)
+      puts_table(rows: rows)
+    end
+
+    def show_domain_details(domain_name)
+      show_admins(domain_name)
+      puts
+      show_accounts(domain_name)
+      puts
+      show_forwards(domain_name)
+      puts
+      show_aliases(domain_name)
+    end
+
     def show_alias_base(title, addresses)
-      report(title, " No. Address                                  Active Go to") do
-        if addresses.empty?
-          puts " No #{title.downcase}"
-          next
-        end
+      rows = []
+      puts_title(title)
 
-        addresses.each_with_index do |a, i|
-          puts "%4d %-40s   %-3s  %s" % [i+1, a.address, a.active_str, a.goto]
-        end
+      if addresses.empty?
+        puts "No #{title.downcase}"
+        return
       end
+
+      headings = ["No.", "Address", "Active", "Go to"]
+      addresses.each_with_index do |a, i|
+        no = i + 1
+        rows << [no.to_s, a.address, a.active_str, a.goto]
+      end
+
+      puts_table(headings: headings, rows: rows)
     end
 
     def puts_registered(name, as_str)
@@ -388,7 +496,7 @@ module PostfixAdmin
     end
 
     def config_file
-      config_file = File.expand_path(CLI.config_file)
+      File.expand_path(CLI.config_file)
     end
 
     def load_config
@@ -409,17 +517,12 @@ module PostfixAdmin
       File.chmod(0600, file)
     end
 
-    def print_line
-      puts "-"*120
+    def puts_table(args)
+      puts Terminal::Table.new(args)
     end
 
-    def report(title, index = nil)
-      puts "\n[#{title}]"
-      print_line if index
-      puts index if index
-      print_line
-      yield
-      print_line
+    def puts_title(title)
+      puts "| #{title} |"
     end
 
     def account_check(user_name)
@@ -455,38 +558,44 @@ module PostfixAdmin
       end
     end
 
-    def change_password(klass, user_name, password)
+    def change_password(klass, user_name, password, scheme: nil, rounds: nil)
       raise Error, "Could not find #{user_name}" unless klass.exists?(user_name)
 
       validate_password(password)
 
       obj = klass.find(user_name)
+      h_password = hashed_password(password, scheme: scheme, rounds: rounds,
+                                   user_name: user_name)
 
-      if obj.update(password: hashed_password(password))
-        puts "the password of #{user_name} was successfully changed."
+      if obj.update(password: h_password)
+        puts "the password of #{user_name} was successfully updated."
       else
         raise "Could not change password of #{klass.name}"
       end
     end
 
-    def max_str(value)
-      case value
-      when 0
-        '--'
-      when -1
-        '0'
-      else
-        value.to_s
-      end
-    end
-
-    private
+    # The default number of rounds for BLF-CRYPT in `doveadm pw` is 5.
+    # However, this method uses 10 rounds by default, similar to
+    # the password_hash() function in PHP.
+    #
+    # https://www.php.net/manual/en/function.password-hash.php
+    # <?php
+    #   echo password_hash("password", PASSWORD_BCRYPT);
+    #
+    # $2y$10$qzRgjWZWfH4VsNQGvp/DNObFSaMiZxXJSzgXqOOS/qtF68qIhhwFe
+    DEFAULT_BLF_CRYPT_ROUNDS = 10
 
-    def hashed_password(password, in_scheme = nil)
+    # Generate a hashed password
+    def hashed_password(password, scheme: nil, rounds: nil, user_name: nil)
       prefix = @base.config[:passwordhash_prefix]
-      scheme = in_scheme || @base.config[:scheme]
-      puts "scheme: #{scheme}"
-      PostfixAdmin::Doveadm.password(password, scheme, prefix)
+      new_scheme = scheme || @base.config[:scheme]
+      new_rounds = if rounds
+                     rounds
+                   elsif new_scheme == "BLF-CRYPT"
+                     DEFAULT_BLF_CRYPT_ROUNDS
+                   end
+      PostfixAdmin::Doveadm.password(password, new_scheme, rounds: new_rounds,
+                                     user_name: user_name, prefix: prefix)
     end
   end
 end