postfix_admin 0.1.1 → 0.2.1

data/lib/postfix_admin/application_record.rb

@@ -0,0 +1,44 @@
+require 'active_record'
+require 'postfix_admin/concerns/existing_timestamp'
+
+module PostfixAdmin
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    include ExistingTimestamp
+
+    RE_DOMAIN_NAME_LIKE_BASE = '([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}'
+    RE_EMAIL_LIKE_BASE = '[^@\s]+@([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,}'
+
+    RE_DOMAIN_NAME_LIKE = /#{RE_DOMAIN_NAME_LIKE_BASE}/
+    RE_EMAIL_LIKE = /#{RE_EMAIL_LIKE_BASE}/
+
+    RE_DOMAIN_NAME_LIKE_WITH_ANCHORS = /\A#{RE_DOMAIN_NAME_LIKE_BASE}\z/
+    RE_EMAIL_LIKE_WITH_ANCHORS = /\A#{RE_EMAIL_LIKE_BASE}\z/
+
+    scope :active, -> { where(active: true) }
+
+    def inactive?
+      !active?
+    end
+
+    def active_str
+      active? ? "Active" : "Inactive"
+    end
+
+    # This is a workaround to set current time to timestamp columns when a record is created.
+    # Activerecord does not insert timestamps if default values are set for the columns.
+    before_create :set_current_time_to_timestamp_columns, if: :has_timestamp_columns?
+
+    def set_current_time_to_timestamp_columns
+      now = Time.now
+      self.created = now
+      self.modified = now
+    end
+
+    def has_timestamp_columns?
+      column_names = self.class.column_names
+      column_names.include?("created") && column_names.include?("modified")
+    end
+  end
+end

data/lib/postfix_admin/base.rb

@@ -1,137 +1,170 @@
-require 'postfix_admin/models'
 require 'postfix_admin/error'
 
 require 'date'
-require 'data_mapper'
+require 'postfix_admin/models'
 
 module PostfixAdmin
   class Base
     attr_reader :config
 
     DEFAULT_CONFIG = {
-      'database'  => 'mysql://postfix:password@localhost/postfix',
+      'database'  => 'mysql2://postfix:password@localhost/postfix',
       'aliases'   => 30,
       'mailboxes' => 30,
-      'maxquota'  => 100
+      'maxquota'  => 100,
+      'scheme'    => 'CRAM-MD5',
+      'passwordhash_prefix' => true
     }
 
     def initialize(config)
-      db_setup(config['database'])
       @config = {}
+      @config[:database]  = config['database']
       @config[:aliases]   = config['aliases']   || 30
       @config[:mailboxes] = config['mailboxes'] || 30
       @config[:maxquota]  = config['maxquota']  || 100
-      @config[:mailbox_quota] = @config[:maxquota] * KB_TO_MB
+      @config[:scheme]    = config['scheme']    || 'CRAM-MD5'
+      @config[:passwordhash_prefix] = if config['passwordhash_prefix'].nil?
+                                        true
+                                      else
+                                        config['passwordhash_prefix']
+                                      end
     end
 
-    def db_setup(database)
-      DataMapper.setup(:default, database)
-      DataMapper.finalize
+    def db_setup
+      raise "'database' parameter is required in '#{CLI.config_file}'" unless @config[:database]
+
+      uri = URI.parse(@config[:database])
+
+      if uri.scheme == "mysql"
+        uri.scheme = "mysql2"
+        warn("Deprecation Warning: Use 'mysql2' as a DB adopter instead of 'mysql' in '#{CLI.config_file}'")
+      end
+
+      if uri.scheme != "mysql2"
+        raise "'#{uri.scheme}' is not supported as a DB adopter. Use 'mysql2' instead in '#{CLI.config_file}'."
+      end
+
+      ActiveRecord::Base.establish_connection(uri.to_s)
+
+    rescue LoadError => e
+      raise e.message
     end
 
     def add_admin_domain(user_name, domain_name)
       admin_domain_check(user_name, domain_name)
 
       admin  = Admin.find(user_name)
-      if admin.has_domain?(domain_name)
-        raise Error, "#{user_name} is already resistered as admin of #{domain_name}."
+      domain = Domain.find(domain_name)
+
+      if admin.has_domain?(domain)
+        raise Error, "#{user_name} is already registered as admin of #{domain_name}."
       end
 
-      domain = Domain.find(domain_name)
-      admin.domains << domain
+      admin.rel_domains << domain
       admin.save or raise "Relation Error: Domain of Admin"
     end
 
     def delete_admin_domain(user_name, domain_name)
       admin_domain_check(user_name, domain_name)
 
-      admin  = Admin.find(user_name)
-      unless admin.has_domain?(domain_name)
-        raise Error, "#{user_name} is not resistered as admin of #{domain_name}."
+      admin = Admin.find(user_name)
+      domain_admin_query = admin.domain_admins.where(domain: domain_name)
+
+      unless domain_admin_query.take
+        raise Error, "#{user_name} is not registered as admin of #{domain_name}."
       end
 
-      domain = Domain.find(domain_name)
-      admin.domains.delete(domain)
-      admin.save or "Could not save Admin"
+      domain_admin_query.delete_all
     end
 
     def add_admin(username, password)
-      if Admin.exist?(username)
-        raise Error, "#{username} is already resistered as admin."
+      password_check(password)
+
+      if Admin.exists?(username)
+        raise Error, "#{username} is already registered as admin."
       end
       admin = Admin.new
       admin.attributes = {
-        :username => username,
-        :password => password,
+        username: username,
+        password: password,
       }
       unless admin.save
-        raise "Could not save Admin #{admin.errors.map{|e| e.to_s}.join}"
+        raise "Could not save Admin #{admin.errors.map(&:to_s).join}"
       end
     end
 
-    def add_account(address, password)
+    def add_account(address, password, in_name = nil)
+      name = in_name || ''
+      password_check(password)
+
       if address !~ /.+\@.+\..+/
         raise Error, "Invalid mail address #{address}"
       end
       user, domain_name = address_split(address)
       path = "#{domain_name}/#{address}/"
 
-      unless Domain.exist?(domain_name)
+      unless Domain.exists?(domain_name)
         raise Error, "Could not find domain #{domain_name}"
       end
 
-      if Alias.exist?(address)
-        raise Error, "#{address} is already resistered."
+      if Alias.exists?(address)
+        raise Error, "#{address} is already registered."
       end
 
       domain = Domain.find(domain_name)
-      domain.aliases << Alias.mailbox(address)
-
-      mailbox = Mailbox.new
-      mailbox.attributes = {
-        :username => address,
-        :password => password,
-        :name     => '',
-        :maildir  => path,
-        :quota    => @config[:mailbox_quota],
-        # :local_part => user,
+
+      attributes = {
+          username: address,
+          password: password,
+          name: name,
+          maildir: path,
+          local_part: user,
+          quota_mb: @config[:maxquota]
       }
-      domain.mailboxes << mailbox
+
+      mailbox = Mailbox.new(attributes)
+
+      domain.rel_mailboxes << mailbox
+
       unless domain.save
-        raise "Could not save Mailbox and Domain #{mailbox.errors.map{|e| e.to_s}.join} #{domain.errors.map{|e| e.to_s}.join}"
+        raise "Could not save Mailbox and Domain #{mailbox.errors.map(&:to_s).join} #{domain.errors.map(&:to_s).join}"
       end
     end
 
     def add_alias(address, goto)
-      if Mailbox.exist?(address)
+      if Mailbox.exists?(address)
         raise Error, "mailbox #{address} is already registered!"
       end
-      if Alias.exist?(address)
+      if Alias.exists?(address)
         raise Error, "alias #{address} is already registered!"
       end
-      user, domain_name = address_split(address)
-      unless Domain.exist?(domain_name)
+
+      local_part, domain_name = address_split(address)
+
+      unless Domain.exists?(domain_name)
         raise Error, "Invalid domain! #{domain_name}"
       end
+
       domain = Domain.find(domain_name)
 
-      new_alias = Alias.new
-      new_alias.attributes = {
-        :address => address,
-        :goto    => goto,
+      attributes = {
+        local_part: local_part,
+        goto: goto
       }
-      domain.aliases << new_alias
+      domain.rel_aliases << Alias.new(attributes)
       domain.save or raise "Could not save Alias"
     end
 
     def delete_alias(address)
-      if Mailbox.exist?(address)
+      if Mailbox.exists?(address)
         raise Error, "Can not delete mailbox by delete_alias. Use delete_account"
       end
-      unless Alias.exist?(address)
+
+      unless Alias.exists?(address)
         raise Error, "#{address} is not found!"
       end
-      Alias.all(:address => address).destroy or raise "Could not destroy Alias"
+
+      Alias.where(address: address).delete_all
     end
 
     def add_domain(domain_name)
@@ -139,56 +172,65 @@ module PostfixAdmin
       if domain_name !~ /.+\..+/
         raise Error, "Ivalid domain! #{domain_name}"
       end
-      if Domain.exist?(domain_name)
+      if Domain.exists?(domain_name)
         raise Error, "#{domain_name} is already registered!"
       end
       domain = Domain.new
       domain.attributes = {
-        :domain_name  => domain_name,
-        :description  => domain_name,
-        :maxaliases   => @config[:aliases],
-        :maxmailboxes => @config[:mailboxes],
-        :maxquota     => @config[:maxquota],
+        domain: domain_name,
+        description: domain_name,
+        aliases: @config[:aliases],
+        mailboxes: @config[:mailboxes],
+        maxquota: @config[:maxquota],
       }
-      domain.save or raise "Could not save Domain"
+      domain.save!
     end
 
     def delete_domain(domain_name)
       domain_name = domain_name.downcase
-      unless Domain.exist?(domain_name)
+      unless Domain.exists?(domain_name)
         raise Error, "Could not find domain #{domain_name}"
       end
 
       domain = Domain.find(domain_name)
-      domain.mailboxes.destroy or raise "Could not destroy Mailbox"
-      domain.aliases.destroy or raise "Could not destroy Alias"
-      admin_names = domain.admins.map{|a| a.username }
-      domain.clear_admins
+      domain.rel_mailboxes.delete_all
+      domain.rel_aliases.delete_all
+
+      admin_names = domain.admins.map(&:username)
+
+      domain.admins.delete_all
 
       admin_names.each do |name|
-        next unless Admin.exist?(name)
+        next unless Admin.exists?(name)
+
         admin = Admin.find(name)
-        admin.destroy or raise "Could not destroy Admin" if admin.domains.empty?
+
+        # check if the admin is needed or not
+        if admin.rel_domains.empty?
+          admin.destroy
+        end
       end
-      domain.destroy or raise "Could not destroy Domain"
+
+      domain.destroy
     end
 
     def delete_admin(user_name)
-      unless Admin.exist?(user_name)
+      unless Admin.exists?(user_name)
         raise Error, "Could not find admin #{user_name}"
       end
+
       admin = Admin.find(user_name)
-      admin.clear_domains
-      admin.destroy or raise "Could not destroy Admin"
+      admin.rel_domains.delete_all
+      admin.destroy!
     end
 
     def delete_account(address)
-      unless Alias.exist?(address) && Mailbox.exist?(address)
+      unless Alias.exists?(address) && Mailbox.exists?(address)
         raise Error, "Could not find account #{address}"
       end
 
-      Mailbox.all(:username => address).destroy or raise "Could not destroy Mailbox"
-      Alias.all(:address => address).destroy or raise "Could not destroy Alias"
+      Mailbox.where(username: address).delete_all
+      Alias.where(address: address).delete_all
     end
 
     def address_split(address)
@@ -198,9 +240,12 @@ module PostfixAdmin
     private
 
     def admin_domain_check(user_name, domain_name)
-      raise Error, "#{user_name} is not resistered as admin." unless Admin.exist?(user_name)
-      raise Error, "Could not find domain #{domain_name}"     unless Domain.exist?(domain_name)
+      raise Error, "#{user_name} is not registered as admin." unless Admin.exists?(user_name)
+      raise Error, "Could not find domain #{domain_name}"     unless Domain.exists?(domain_name)
     end
 
+    def password_check(password)
+      raise Error, "Empty password" if password.nil? || password.empty?
+    end
   end
 end

data/lib/postfix_admin/cli.rb

@@ -1,9 +1,11 @@
 require 'yaml'
 require 'postfix_admin'
+require 'postfix_admin/doveadm'
 
 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
@@ -19,11 +21,24 @@ module PostfixAdmin
       @config_file = value
     end
 
+    def db_setup
+      @base.db_setup
+    end
+
     def show(name)
       name = name.downcase if name
 
       if name =~ /@/
-        show_account(name)
+        if Admin.exists?(name)
+          show_admin_details(name)
+        end
+
+        if Mailbox.exists?(name)
+          show_account_details(name)
+        elsif Alias.exists?(name)
+          show_alias_details(name)
+        end
+
         return
       end
 
@@ -39,7 +54,7 @@ module PostfixAdmin
       end
     end
 
-    def show_summary(domain_name=nil)
+    def show_summary(domain_name = nil)
       title = "Summary"
       if domain_name
         domain_name = domain_name.downcase
@@ -50,14 +65,15 @@ module PostfixAdmin
       report(title) do
         if domain_name
           domain = Domain.find(domain_name)
-          puts "Mailboxes : %4d / %4s"    % [domain.mailboxes.count, max_str(domain.maxmailboxes)]
-          puts "Aliases   : %4d / %4s"    % [domain.num_total_aliases, max_str(domain.maxaliases)]
+          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.all_without_special_domain.count
+          puts "Domains   : %4d" % Domain.without_all.count
           puts "Admins    : %4d" % Admin.count
           puts "Mailboxes : %4d" % Mailbox.count
-          puts "Aliases   : %4d" % Domain.num_total_aliases
+          puts "Aliases   : %4d" % Alias.pure.count
         end
       end
     end
@@ -69,34 +85,58 @@ module PostfixAdmin
       add_admin_domain(admin, domain_name)
     end
 
-    def show_account(user_name)
+    def show_account_details(user_name)
       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
+    end
+
+    def show_admin_details(name)
+      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
+    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
     end
 
     def show_domain
-      index = " No. Domain                          Aliases   Mailboxes     Quota (MB)"
+      index = " No. Domain                          Aliases   Mailboxes     Quota (MB)  Active"
       report('Domains', index) do
-        if Domain.all_without_special_domain.empty?
+        if Domain.without_all.empty?
           puts " No domains"
           next
         end
 
-        Domain.all_without_special_domain.each_with_index do |d, i|
-          puts "%4d %-30s %3d /%3s   %3d /%3s %10d" %
-            [i+1, d.domain_name, d.num_total_aliases, max_str(d.maxaliases),
-             d.mailboxes.count, max_str(d.maxmailboxes), d.maxquota]
+        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
       end
-
     end
 
     def add_domain(domain_name)
@@ -104,18 +144,6 @@ module PostfixAdmin
       puts_registered(domain_name, "a domain")
     end
 
-    def super_admin(user_name, disable)
-      admin_check(user_name)
-
-      if disable
-        Admin.find(user_name).super_admin = false
-        puts "Successfully disabled super admin flag of #{user_name}"
-      else
-        Admin.find(user_name).super_admin = true
-        puts "Successfully enabled super admin flag of #{user_name}"
-      end
-    end
-
     def change_admin_password(user_name, password)
       change_password(Admin, user_name, password)
     end
@@ -124,13 +152,29 @@ module PostfixAdmin
       change_password(Mailbox, user_name, password)
     end
 
+    def edit_admin(admin_name, options)
+      admin_check(admin_name)
+      admin = Admin.find(admin_name)
+
+      unless options[:super].nil?
+        admin.super_admin = options[:super]
+      end
+
+      admin.active = options[:active] unless options[:active].nil?
+      admin.save!
+
+      puts "Successfully updated #{admin_name}"
+      show_admin_details(admin_name)
+    end
+
     def edit_domain(domain_name, options)
       domain_check(domain_name)
       domain = Domain.find(domain_name)
-      domain.maxaliases   = options[:aliases]   if options[:aliases]
-      domain.maxmailboxes = options[:mailboxes] if options[:mailboxes]
+      domain.aliases   = options[:aliases]   if options[:aliases]
+      domain.mailboxes = options[:mailboxes] if options[:mailboxes]
       domain.maxquota     = options[:maxquota]  if options[:maxquota]
-      domain.save or raise "Could not save Domain"
+      domain.active       = options[:active] unless options[:active].nil?
+      domain.save!
 
       puts "Successfully updated #{domain_name}"
       show_summary(domain_name)
@@ -141,9 +185,9 @@ module PostfixAdmin
       puts_deleted(domain_name)
     end
 
-    def show_admin(domain_name=nil)
-      admins = domain_name ? Admin.select{|a| a.has_domain?(domain_name)} : Admin.all
-      index = " No. Admin                                        Domains Password"
+    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"
@@ -151,18 +195,17 @@ module PostfixAdmin
         end
 
         admins.each_with_index do |a, i|
-          domains = a.super_admin? ? 'Super admin' : a.domains.count
-          puts "%4d %-40s %11s %s" % [i+1, a.username, domains, a.password]
+          domains = a.super_admin? ? 'Super admin' : a.rel_domains.count
+          puts "%4d %-40s %11s   %-3s" % [i+1, a.username, domains, a.active_str]
         end
       end
-
     end
 
     def show_address(domain_name)
       domain_check(domain_name)
 
-      mailboxes = Domain.find(domain_name).mailboxes
-      index = " No. Email                                     Quota (MB) Password        Maildir"
+      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"
@@ -171,16 +214,15 @@ module PostfixAdmin
 
         mailboxes.each_with_index do |m, i|
           quota = m.quota.to_f/ KB_TO_MB.to_f
-          puts "%4d %-40s  %10s %-15s %s" % [i+1, m.username, max_str(quota.to_i), m.password, m.maildir]
+          puts "%4d %-30s  %-20s %10s   %-3s  %s" % [i+1, m.username, m.name, max_str(quota.to_i), m.active_str, m.maildir]
         end
       end
-
     end
 
     def show_alias(domain_name)
       domain_check(domain_name)
 
-      forwards, aliases = Domain.find(domain_name).aliases.partition{|a| a.mailbox?}
+      forwards, aliases = Domain.find(domain_name).rel_aliases.partition { |a| a.mailbox? }
 
       forwards.delete_if do |f|
         f.address == f.goto
@@ -192,21 +234,22 @@ module PostfixAdmin
 
     def show_admin_domain(user_name)
       admin = Admin.find(user_name)
-      if admin.domains.empty?
+      if admin.rel_domains.empty?
         puts "\nNo domain in database"
         return
       end
 
       report("Domains (#{user_name})", " No. Domain") do
-        admin.domains.each_with_index do |d, i|
-          puts "%4d %-30s" % [i+1, d.domain_name]
+        admin.rel_domains.each_with_index do |d, i|
+          puts "%4d %-30s" % [i + 1, d.domain]
         end
       end
     end
 
-    def add_admin(user_name, password, super_admin=false)
+    def add_admin(user_name, password, super_admin = false, scheme = nil)
       validate_password(password)
-      @base.add_admin(user_name, password)
+
+      @base.add_admin(user_name, hashed_password(password, scheme))
       if super_admin
         Admin.find(user_name).super_admin = true
         puts_registered(user_name, "a super admin")
@@ -225,10 +268,12 @@ module PostfixAdmin
       puts "#{domain_name} was successfully deleted from #{user_name}"
     end
 
-    def add_account(address, password)
+    def add_account(address, password, scheme = nil, name = nil)
       validate_password(password)
-      @base.add_account(address, password)
+
+      @base.add_account(address, hashed_password(password, scheme), name)
       puts_registered(address, "an account")
+      show_account_details(address)
     end
 
     def add_alias(address, goto)
@@ -239,11 +284,30 @@ module PostfixAdmin
     def edit_account(address, options)
       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.save or raise "Could not save Mailbox"
+      mailbox.active = options[:active] unless options[:active].nil?
+      mailbox.save!
+
+      if options[:goto]
+        mail_alias = Alias.find(address)
+        mail_alias.goto = options[:goto]
+        mail_alias.save!
+      end
 
       puts "Successfully updated #{address}"
-      show_account(address)
+      show_account_details(address)
+    end
+
+    def edit_alias(address, options)
+      alias_check(address)
+      mail_alias = Alias.find(address)
+      mail_alias.goto = options[:goto] if options[:goto]
+      mail_alias.active = options[:active] unless options[:active].nil?
+      mail_alias.save or raise "Could not save Alias"
+
+      puts "Successfully updated #{address}"
+      show_alias_details(address)
     end
 
     def delete_alias(address)
@@ -261,17 +325,56 @@ 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}"
+      end
+    end
+
+    def dump
+      puts "Admins"
+      puts "User Name,Password,Super Admin,Active"
+      Admin.all.each do |a|
+        puts [a.username, %Q!"#{a.password}"!, a.super_admin?, a.active].join(',')
+      end
+      puts
+      puts "Domains"
+      puts "Domain Name,Max Quota,Active"
+      Domain.without_all.each do |d|
+        puts [d.domain, d.maxquota, d.active].join(',')
+      end
+      puts
+      puts "Mailboxes"
+      puts "User Name,Name,Password,Quota,Maildir,Active"
+      Mailbox.all.each do |m|
+        puts [m.username, %Q!"#{m.name}"!, %Q!"#{m.password}"!, m.quota, %Q!"#{m.maildir}"!, m.active].join(',')
+      end
+      puts
+      puts "Aliases"
+      puts "Address,Go to,Active"
+      Alias.all.select { |a| !a.mailbox? }.each do |a|
+        puts [a.address, %Q!"#{a.goto}"!, a.active].join(',')
+      end
+      puts
+      puts "Forwards"
+      puts "Address,Go to,Active"
+      Alias.all.select { |a| a.mailbox? && a.goto != a.address }.each do |a|
+        puts [a.address, %Q!"#{a.goto}"!, a.active].join(',')
+      end
+    end
+
     private
 
     def show_alias_base(title, addresses)
-      report(title, " No. Address                                  Go to") do
+      report(title, " No. Address                                  Active Go to") do
         if addresses.empty?
           puts " No #{title.downcase}"
           next
         end
 
         addresses.each_with_index do |a, i|
-          puts "%4d %-40s %s" % [i+1, a.address, a.goto]
+          puts "%4d %-40s   %-3s  %s" % [i+1, a.address, a.active_str, a.goto]
         end
       end
     end
@@ -310,7 +413,7 @@ module PostfixAdmin
       puts "-"*120
     end
 
-    def report(title, index=nil)
+    def report(title, index = nil)
       puts "\n[#{title}]"
       print_line if index
       puts index if index
@@ -320,7 +423,7 @@ module PostfixAdmin
     end
 
     def account_check(user_name)
-      unless Mailbox.exist?(user_name) && Alias.exist?(user_name)
+      unless Mailbox.exists?(user_name) && Alias.exists?(user_name)
         raise Error, %Q!Could not find account "#{user_name}"!
       end
     end
@@ -333,13 +436,17 @@ module PostfixAdmin
       klass_check(Mailbox, address)
     end
 
+    def alias_check(address)
+      klass_check(Alias, address)
+    end
+
     def admin_check(user_name)
       klass_check(Admin, user_name)
     end
 
     def klass_check(klass, name)
       object_name = klass.name.gsub(/PostfixAdmin::/, '').downcase
-      raise Error, %Q!Could not find #{object_name} "#{name}"! unless klass.exist?(name)
+      raise Error, %Q!Could not find #{object_name} "#{name}"! unless klass.exists?(name)
     end
 
     def validate_password(password)
@@ -349,13 +456,13 @@ module PostfixAdmin
     end
 
     def change_password(klass, user_name, password)
-      raise Error, "Could not find #{user_name}" unless klass.exist?(user_name)
+      raise Error, "Could not find #{user_name}" unless klass.exists?(user_name)
 
       validate_password(password)
 
       obj = klass.find(user_name)
-      obj.password = password
-      if obj.save
+
+      if obj.update(password: hashed_password(password))
         puts "the password of #{user_name} was successfully changed."
       else
         raise "Could not change password of #{klass.name}"
@@ -373,5 +480,13 @@ module PostfixAdmin
       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, prefix)
+    end
   end
 end