postfix_admin 0.2.0 → 0.3.0

data/lib/postfix_admin/cli.rb

@@ -1,10 +1,12 @@
 require 'yaml'
 require 'postfix_admin'
 require 'postfix_admin/doveadm'
+require 'terminal-table'
 
 module PostfixAdmin
   class CLI
-    @config_file = '~/.postfix_admin.conf'
+    DEFAULT_CONFIG_PATH = '~/.postfix_admin.conf'
+    @config_file = DEFAULT_CONFIG_PATH
     MIN_NUM_PASSWORD_CHARACTER = 5
 
     def initialize
@@ -28,55 +30,49 @@ 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
+        # no argument: show all domains and admins
         show_domain
+        puts
         show_admin
       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
 
+    # Set up a domain
+    # Add a domain, add an admin, and grant the admin access to the domain
     def setup_domain(domain_name, password)
       admin = "admin@#{domain_name}"
       add_domain(domain_name)
@@ -84,62 +80,75 @@ module PostfixAdmin
       add_admin_domain(admin, domain_name)
     end
 
-    def show_account_details(user_name)
+    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_mb_str]
+      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
+      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
 
@@ -173,6 +182,7 @@ 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}"
@@ -186,36 +196,44 @@ module PostfixAdmin
 
     def show_admin(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 = %w[No. Admin Domains Active]
 
-        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]
+      end
+
+      puts_table(headings: headings, rows: rows)
     end
 
     def show_address(domain_name)
       domain_check(domain_name)
 
+      rows = []
       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
+      headings = ["No.", "Email", "Name", "Quota (MB)", "Active", "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("Addresses")
+      if mailboxes.empty?
+        puts "No addresses"
+        return
+      end
+
+      mailboxes.each_with_index do |m, i|
+        no = i + 1
+        rows << [no.to_s, m.username, m.name, m.quota_mb_str,
+                 m.active_str, m.maildir]
       end
+
+      puts_table(headings: headings, rows: rows)
     end
 
     def show_alias(domain_name)
@@ -228,21 +246,24 @@ module PostfixAdmin
       end
 
       show_alias_base("Forwards", forwards)
+      puts
       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)
@@ -270,9 +291,8 @@ module PostfixAdmin
     def add_account(address, password, scheme = nil, name = nil)
       validate_password(password)
 
-      @base.add_account(address, hashed_password(password, scheme), name)
+      @base.add_account(address, hashed_password(password, scheme), name: name)
       puts_registered(address, "an account")
-      show_account_details(address)
     end
 
     def add_alias(address, goto)
@@ -324,11 +344,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
@@ -365,17 +399,58 @@ 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_admin(domain_name)
+      puts
+      show_address(domain_name)
+      puts
+      show_alias(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)
@@ -387,7 +462,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
@@ -408,17 +483,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)
@@ -468,23 +538,10 @@ module PostfixAdmin
       end
     end
 
-    def max_str(value)
-      case value
-      when 0
-        '--'
-      when -1
-        '0'
-      else
-        value.to_s
-      end
-    end
-
-    private
-
     def hashed_password(password, in_scheme = nil)
+      prefix = @base.config[:passwordhash_prefix]
       scheme = in_scheme || @base.config[:scheme]
-      puts "scheme: #{scheme}"
-      PostfixAdmin::Doveadm.password(password, scheme)
+      PostfixAdmin::Doveadm.password(password, scheme, prefix)
     end
   end
 end

data/lib/postfix_admin/concerns/dovecot_cram_md5_password.rb

@@ -12,7 +12,6 @@ module DovecotCramMD5Password
     end
 
     attr_reader :password_unencrypted
-    attr_accessor :password_unencrypted_confirmation
   end
 
   def password_unencrypted=(unencrypted_password)

data/lib/postfix_admin/domain.rb

@@ -8,91 +8,82 @@ module PostfixAdmin
                                  message: "must be a valid domain name" }
     validates :transport, presence: true
 
+    # max aliases (Disabled: -1, Unlimited: 0)
     validates :aliases, presence: true,
                         numericality: { only_integer: true,
-                                        greater_than_or_equal_to: 0 }
+                                        greater_than_or_equal_to: -1 }
+    # max mailboxes (Disabled: -1, Unlimited: 0)
     validates :mailboxes, presence: true,
                           numericality: { only_integer: true,
-                                          greater_than_or_equal_to: 0 }
+                                          greater_than_or_equal_to: -1 }
+
+    # max quota (MB) for each mailbox (Unlimited: 0)
+    # It's not sure what 'disabled' means for max quota.
+    # So it's better not to allow users to set `maxquota` to -1.
     validates :maxquota, presence: true,
                          numericality: { only_integer: true,
                                          greater_than_or_equal_to: 0 }
 
+    # mailboxes that belong to this domain
     has_many :rel_mailboxes, class_name: "Mailbox", foreign_key: :domain,
                              dependent: :destroy
+    # aliases that belong to this domain
     has_many :rel_aliases, class_name: "Alias", foreign_key: :domain,
                            dependent: :destroy
 
+    # It causes errors to set `dependent: :destroy` as other columns
+    # because the domain_admins table doesn't have a single primary key.
+    #
+    # PostfixAdmin::DomainAdmin Load (0.5ms)  SELECT `domain_admins`.* FROM `domain_admins` WHERE `domain_admins`.`domain` = 'example.com'
+    # PostfixAdmin::DomainAdmin Destroy (1.1ms)  DELETE FROM `domain_admins` WHERE `domain_admins`.`` IS NULL
+    #
+    # ActiveRecord::StatementInvalid: Mysql2::Error: Unknown column 'domain_admins.' in 'where clause'
+    # from /usr/local/bundle/gems/mysql2-0.5.4/lib/mysql2/client.rb:148:in `_query'
+    # Caused by Mysql2::Error: Unknown column 'domain_admins.' in 'where clause'
+    # from /usr/local/bundle/gems/mysql2-0.5.4/lib/mysql2/client.rb:148:in `_query'
+    #
+    # It works well with `dependent: :delete_all` instead.
+    #
+    # PostfixAdmin::DomainAdmin Destroy (0.4ms)  DELETE FROM `domain_admins` WHERE `domain_admins`.`domain` = 'example.com'
     has_many :domain_admins, foreign_key: :domain, dependent: :delete_all
+
     has_many :admins, through: :domain_admins
 
     before_validation do |domain|
-      domain.domain = domain.domain.downcase unless domain.domain.empty?
+      domain.domain = domain.domain&.downcase
       domain.transport = "virtual"
     end
 
     scope :without_all, -> { where.not(domain: "ALL") }
 
+    # aliases that don't belong to a mailbox
     def pure_aliases
       rel_aliases.pure
     end
 
-    def aliases_unlimited?
-      aliases.zero?
-    end
-
-    def mailboxes_unlimited?
-      mailboxes.zero?
-    end
-
     def aliases_str
-      num_str(aliases)
+      max_num_str(aliases)
     end
 
     def mailboxes_str
-      num_str(mailboxes)
-    end
-
-    def aliases_short_str
-      num_short_str(aliases)
-    end
-
-    def mailboxes_short_str
-      num_short_str(mailboxes)
+      max_num_str(mailboxes)
     end
 
     def maxquota_str
-      if maxquota.zero?
-        "Unlimited"
-      else
-        "#{maxquota} MB"
-      end
-    end
-
-    def maxquota_short_str
-      if maxquota.zero?
-        "--"
-      else
-        "#{maxquota} MB"
-      end
+      max_num_str(maxquota)
     end
 
     private
 
-    def num_str(num)
-      if num.zero?
+    def max_num_str(num)
+      case num
+      when -1
+        "Disabled"
+      when 0
         "Unlimited"
       else
         num.to_s
       end
     end
-
-    def num_short_str(num)
-      if num.zero?
-        "--"
-      else
-        num.to_s
-      end
-    end
   end
 end

data/lib/postfix_admin/doveadm.rb

@@ -9,24 +9,25 @@ module PostfixAdmin
       result.split
     end
 
-    def self.password(in_password, in_scheme)
+    def self.password(in_password, in_scheme, prefix)
       password = Shellwords.escape(in_password)
-      scheme  = Shellwords.escape(in_scheme)
-      stdin, stdout, stderr = Open3.popen3("#{self.command_name} -s #{scheme} -p #{password}")
+      scheme = Shellwords.escape(in_scheme)
+      _stdin, stdout, stderr = Open3.popen3("#{self.command_name} -s #{scheme} -p #{password}")
+
       if stderr.readlines.to_s =~ /Fatal:/
         raise Error, stderr.readlines
       else
-        stdout.readlines.first.chomp
+        res = stdout.readlines.first.chomp
+        if prefix
+          res
+        else
+          res.gsub("{#{scheme}}", "")
+        end
       end
     end
 
     def self.command_name
-      begin
-        Open3.capture3("doveadm pw -l")[2].exited?
-        "doveadm pw"
-      rescue Errno::ENOENT
-        "dovecotpw"
-      end
+      "doveadm pw"
     end
   end
 end

data/lib/postfix_admin/mailbox.rb

@@ -12,9 +12,13 @@ module PostfixAdmin
                                    message: "must be a valid email address" }
     validates :maildir, presence: true, uniqueness: { case_sensitive: false }
     validates :local_part, presence: true
+
+    # quota (KB)
     validates :quota, presence: true,
                       numericality: { only_integer: true,
                                       greater_than_or_equal_to: 0 }
+
+    # quota (MB), which actually doesn't exist in DB
     validates :quota_mb, presence: true,
                          numericality: { only_integer: true,
                                          greater_than_or_equal_to: 0 }
@@ -63,7 +67,7 @@ module PostfixAdmin
         mailbox.quota = 0
       end
       mailbox.username = "#{mailbox.local_part}@#{mailbox.domain}"
-      mailbox.maildir = "#{mailbox.domain}/#{mailbox.username}/"
+      mailbox.maildir ||= "#{mailbox.domain}/#{mailbox.username}/"
       mailbox.build_alias(local_part: mailbox.local_part, goto: mailbox.username,
                           domain: mailbox.domain)
     end
@@ -77,12 +81,16 @@ module PostfixAdmin
       end
     end
 
-    def quota_str
-      if quota.zero?
-        "--"
+    def quota_mb_str
+      case quota
+      when -1
+        # It's not sure what 'disabled' means for quota.
+        "Disabled"
+      when 0
+        "Unlimited"
       else
-        quota_mb = quota / KB_TO_MB
-        "#{quota_mb} MB"
+        mb_size = quota / KB_TO_MB
+        mb_size.to_s
       end
     end
   end