postfix_admin 0.1.0 → 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 03fe6501c97e53bf66c3fa2f783e8b2e40cc18da
+  data.tar.gz: 0a7c400bee5d1f953ea9f2d03475b8c1e182653f
+SHA512:
+  metadata.gz: b976ae17e338b7bd8154a092bb1d9ed91274b3cb1f008fc1d98e0b55b045dd28966e1d912cd35315bd75ce3005d2bad2e286d29d869967038e461c6867ad31e2
+  data.tar.gz: 56b944669124660d726addfcd2258543845b61170ea68cae3189d7ff87b45e4d2809ba2a0bfbea274d8338ada8e10e64408e672713531043614c28dd6bc07275

data/README.md

@@ -2,6 +2,17 @@
 
 Command Line Tools of Postfix Admin
 
+## Description
+
+Postfix Admin Web Site http://postfixadmin.sourceforge.net/
+
+Sourceforge page http://sourceforge.net/projects/postfixadmin/
+
+This software supports only MySQL as database for Postfix Admin.
+PostgreSQL is not supported.
+
+Postfix Admin 2.2.0 is supported.
+
 ## Installation
 
 Install postfix_admin as:
@@ -10,6 +21,10 @@ Install postfix_admin as:
 
 ## Usage
 
+List the postfix_admin subcommands as:
+
+    $ postfix_admin
+
 ```
   postfix_admin account_passwd user@example.com new_password    # Change password of account
   postfix_admin add_account user@example.com password           # Add an account

data/bin/postfix_admin

@@ -2,8 +2,4 @@
 
 require 'postfix_admin/runner'
 
-begin
-  PostfixAdmin::Runner.start
-rescue => e
-  warn e.message
-end
+PostfixAdmin::Runner.start

data/lib/postfix_admin.rb

@@ -1,2 +1,6 @@
 require "postfix_admin/version"
 require "postfix_admin/base"
+
+module PostfixAdmin
+  KB_TO_MB = 1024000
+end

data/lib/postfix_admin/base.rb

@@ -21,7 +21,7 @@ module PostfixAdmin
       @config[:aliases]   = config['aliases']   || 30
       @config[:mailboxes] = config['mailboxes'] || 30
       @config[:maxquota]  = config['maxquota']  || 100
-      @config[:mailbox_quota] = @config[:maxquota] * 1024 * 1000
+      @config[:mailbox_quota] = @config[:maxquota] * KB_TO_MB
     end
 
     def db_setup(database)
@@ -29,17 +29,12 @@ module PostfixAdmin
       DataMapper.finalize
     end
 
-    def add_admin_domain(username, domain_name)
-      unless Admin.exist?(username)
-        raise Error, "#{username} is not resistered as admin."
-      end
-      unless Domain.exist?(domain_name)
-        raise Error, "Could not find domain #{domain_name}"
-      end
+    def add_admin_domain(user_name, domain_name)
+      admin_domain_check(user_name, domain_name)
 
-      admin  = Admin.find(username)
+      admin  = Admin.find(user_name)
       if admin.has_domain?(domain_name)
-        raise Error, "#{username} is already resistered as admin of #{domain_name}."
+        raise Error, "#{user_name} is already resistered as admin of #{domain_name}."
       end
 
       domain = Domain.find(domain_name)
@@ -47,6 +42,19 @@ module PostfixAdmin
       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}."
+      end
+
+      domain = Domain.find(domain_name)
+      admin.domains.delete(domain)
+      admin.save or "Could not save Admin"
+    end
+
     def add_admin(username, password)
       if Admin.exist?(username)
         raise Error, "#{username} is already resistered as admin."
@@ -56,7 +64,9 @@ module PostfixAdmin
         :username => username,
         :password => password,
       }
-      admin.save or raise "Could not save Admin"
+      unless admin.save
+        raise "Could not save Admin #{admin.errors.map{|e| e.to_s}.join}"
+      end
     end
 
     def add_account(address, password)
@@ -75,12 +85,7 @@ module PostfixAdmin
       end
 
       domain = Domain.find(domain_name)
-      mail_alias = Alias.new
-      mail_alias.attributes = {
-        :address     => address,
-        :goto        => address,
-      }
-      domain.aliases << mail_alias
+      domain.aliases << Alias.mailbox(address)
 
       mailbox = Mailbox.new
       mailbox.attributes = {
@@ -92,7 +97,9 @@ module PostfixAdmin
         # :local_part => user,
       }
       domain.mailboxes << mailbox
-      domain.save or raise "Could not save Domain"
+      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}"
+      end
     end
 
     def add_alias(address, goto)
@@ -128,6 +135,7 @@ module PostfixAdmin
     end
 
     def add_domain(domain_name)
+      domain_name = domain_name.downcase
       if domain_name !~ /.+\..+/
         raise Error, "Ivalid domain! #{domain_name}"
       end
@@ -146,6 +154,7 @@ module PostfixAdmin
     end
 
     def delete_domain(domain_name)
+      domain_name = domain_name.downcase
       unless Domain.exist?(domain_name)
         raise Error, "Could not find domain #{domain_name}"
       end
@@ -153,9 +162,14 @@ module PostfixAdmin
       domain = Domain.find(domain_name)
       domain.mailboxes.destroy or raise "Could not destroy Mailbox"
       domain.aliases.destroy or raise "Could not destroy Alias"
-      domain.domain_admins.destroy or raise "Could not destroy DomainAdmin"
-      delete_unnecessary_admins
+      admin_names = domain.admins.map{|a| a.username }
+      domain.clear_admins
 
+      admin_names.each do |name|
+        next unless Admin.exist?(name)
+        admin = Admin.find(name)
+        admin.destroy or raise "Could not destroy Admin" if admin.domains.empty?
+      end
       domain.destroy or raise "Could not destroy Domain"
     end
 
@@ -164,7 +178,7 @@ module PostfixAdmin
         raise Error, "Could not find admin #{user_name}"
       end
       admin = Admin.find(user_name)
-      admin.domain_admins.destroy or raise "Could not destroy DomainAdmin"
+      admin.clear_domains
       admin.destroy or raise "Could not destroy Admin"
     end
 
@@ -177,12 +191,16 @@ module PostfixAdmin
       Alias.all(:address => address).destroy or raise "Could not destroy Alias"
     end
 
-    def delete_unnecessary_admins
-      Admin.unnecessary.destroy or raise "Could not destroy Admin"
-    end
-
     def address_split(address)
       address.split('@')
     end
+
+    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)
+    end
+
   end
 end

data/lib/postfix_admin/cli.rb

@@ -3,21 +3,36 @@ require 'postfix_admin'
 
 module PostfixAdmin
   class CLI
-    CONFIG_FILE = '~/.postfix_admin.conf'
+    @config_file = '~/.postfix_admin.conf'
     MIN_NUM_PASSWORD_CHARACTER = 5
 
     def initialize
       @config = load_config
-      @base = PostfixAdmin::Base.new(@config)
+      @base = Base.new(@config)
     end
 
-    def show(domain)
-      show_summary(domain)
+    def self.config_file
+      @config_file
+    end
+
+    def self.config_file=(value)
+      @config_file = value
+    end
 
-      if domain
-        show_admin(domain)
-        show_address(domain)
-        show_alias(domain)
+    def show(name)
+      name = name.downcase if name
+
+      if name =~ /@/
+        show_account(name)
+        return
+      end
+
+      show_summary(name)
+
+      if name
+        show_admin(name)
+        show_address(name)
+        show_alias(name)
       else
         show_domain
         show_admin
@@ -27,6 +42,7 @@ module PostfixAdmin
     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
@@ -34,9 +50,9 @@ module PostfixAdmin
       report(title) do
         if domain_name
           domain = Domain.find(domain_name)
-          puts "Mailboxes : %4d"    % domain.mailboxes.count
-          puts "Aliases   : %4d"    % domain.num_total_aliases
-          puts "Quota     : %4d MB" % domain.maxquota
+          puts "Mailboxes : %4d / %4s"    % [domain.mailboxes.count, max_str(domain.maxmailboxes)]
+          puts "Aliases   : %4d / %4s"    % [domain.num_total_aliases, max_str(domain.maxaliases)]
+          puts "Max Quota : %4d MB" % domain.maxquota
         else
           puts "Domains   : %4d" % Domain.all_without_special_domain.count
           puts "Admins    : %4d" % Admin.count
@@ -46,38 +62,50 @@ module PostfixAdmin
       end
     end
 
-    def setup_domain(domain, password)
-      admin = "admin@#{domain}"
-      add_domain(domain)
+    def setup_domain(domain_name, password)
+      admin = "admin@#{domain_name}"
+      add_domain(domain_name)
       add_admin(admin, password)
-      add_admin_domain(admin, domain)
+      add_admin_domain(admin, domain_name)
+    end
+
+    def show_account(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 "Password : %s" % mailbox.password
+        puts "Quota    : %d MB" % max_str(mailbox.quota / KB_TO_MB)
+        puts "Go to    : %s" % mail_alias.goto
+      end
     end
 
     def show_domain
-      index = " No. Domain                Aliases   Mailboxes     Quota (MB)"
+      index = " No. Domain                          Aliases   Mailboxes     Quota (MB)"
       report('Domains', index) do
-        if Domain.all_without_special_domain.count == 0
+        if Domain.all_without_special_domain.empty?
           puts " No domains"
-        else
-          Domain.all_without_special_domain.each_with_index do |d, i|
-            puts "%4d %-20s %3d /%3d   %3d /%3d %10d" %
-              [i+1, d.domain_name, d.num_total_aliases, d.maxaliases,
-               d.mailboxes.count, d.maxmailboxes, d.maxquota]
-          end
+          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]
         end
       end
+
     end
 
-    def add_domain(domain)
-      if @base.add_domain(domain)
-        puts %Q!"#{domain}" was successfully registered.!
-      end
+    def add_domain(domain_name)
+      @base.add_domain(domain_name)
+      puts_registered(domain_name, "a domain")
     end
 
     def super_admin(user_name, disable)
-      unless Admin.exist?(user_name)
-        raise Error, "Could not find admin #{user_name}"
-      end
+      admin_check(user_name)
 
       if disable
         Admin.find(user_name).super_admin = false
@@ -96,124 +124,158 @@ module PostfixAdmin
       change_password(Mailbox, user_name, password)
     end
 
-    def delete_domain(domain)
-      if @base.delete_domain(domain)
-        puts_deleted(domain)
-      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.maxquota     = options[:maxquota]  if options[:maxquota]
+      domain.save or raise "Could not save Domain"
+
+      puts "Successfully updated #{domain_name}"
+      show_summary(domain_name)
+    end
+
+    def delete_domain(domain_name)
+      @base.delete_domain(domain_name)
+      puts_deleted(domain_name)
     end
 
-    def show_admin(domain=nil)
-      admins = domain ? Admin.select{|a| a.has_domain?(domain)} : Admin.all
-      index = " No. Admin                              Domains Password"
+    def show_admin(domain_name=nil)
+      admins = domain_name ? Admin.select{|a| a.has_domain?(domain_name)} : Admin.all
+      index = " No. Admin                                        Domains Password"
       report("Admins", index) do
-        if admins.count == 0
+        if admins.empty?
           puts " No admins"
-        else
-          admins.each_with_index do |a, i|
-            domains = a.super_admin? ? 'Super admin' : a.domains.count
-            puts "%4d %-30s %11s %s" % [i+1, a.username, domains, a.password]
-          end
+          next
+        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]
         end
       end
 
     end
 
-    def show_address(domain)
-      domain_check(domain)
+    def show_address(domain_name)
+      domain_check(domain_name)
 
-      mailboxes = Domain.find(domain).mailboxes
-      index = " No. Email                           Quota (MB) Password"
+      mailboxes = Domain.find(domain_name).mailboxes
+      index = " No. Email                                     Quota (MB) Password        Maildir"
       report("Addresses", index) do
-        if mailboxes.count == 0
+        if mailboxes.empty?
           puts " No addresses"
-        else
-          mailboxes.each_with_index do |m, i|
-            quota = m.quota.to_f/1024000.0
-            puts "%4d %-30s  %10.1f %s" % [i+1, m.username, quota, m.password]
-          end
+          next
+        end
+
+        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]
         end
       end
 
     end
 
-    def show_alias(domain)
-      domain_check(domain)
+    def show_alias(domain_name)
+      domain_check(domain_name)
 
-      aliases = Domain.find(domain).aliases.find_all do |mail_alias|
-        mail_alias.address != mail_alias.goto
-      end
+      forwards, aliases = Domain.find(domain_name).aliases.partition{|a| a.mailbox?}
 
-      index = " No. Address                        Go to"
-      report("Aliases", index) do
-        if aliases.count == 0
-          puts " No aliases"
-        else
-          aliases.each_with_index do |a, i|
-            puts "%4d %-30s %s" % [i+1, a.address, a.goto]
-          end
-        end
+      forwards.delete_if do |f|
+        f.address == f.goto
       end
 
+      show_alias_base("Forwards", forwards)
+      show_alias_base("Aliases",  aliases)
     end
 
     def show_admin_domain(user_name)
       admin = Admin.find(user_name)
-      if admin.domains.count == 0
+      if admin.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 %-20s" % [i+1, d.domain_name]
+          puts "%4d %-30s" % [i+1, d.domain_name]
         end
       end
     end
 
     def add_admin(user_name, password, super_admin=false)
       validate_password(password)
-      if @base.add_admin(user_name, password)
-        if super_admin
-          Admin.find(user_name).super_admin = true
-          puts_registered(user_name, "a super admin")
-        else
-          puts_registered(user_name, "an admin")
-        end
+      @base.add_admin(user_name, password)
+      if super_admin
+        Admin.find(user_name).super_admin = true
+        puts_registered(user_name, "a super admin")
+      else
+        puts_registered(user_name, "an admin")
       end
     end
 
-    def add_admin_domain(user_name, domain)
-      if @base.add_admin_domain(user_name, domain)
-        puts_registered(domain, "a domain of #{user_name}")
-      end
+    def add_admin_domain(user_name, domain_name)
+      @base.add_admin_domain(user_name, domain_name)
+      puts_registered(domain_name, "a domain of #{user_name}")
+    end
+
+    def delete_admin_domain(user_name, domain_name)
+      @base.delete_admin_domain(user_name, domain_name)
+      puts "#{domain_name} was successfully deleted from #{user_name}"
     end
 
     def add_account(address, password)
       validate_password(password)
-      if @base.add_account(address, password)
-        puts_registered(address, "an account")
-      end
+      @base.add_account(address, password)
+      puts_registered(address, "an account")
     end
 
     def add_alias(address, goto)
-      if @base.add_alias(address, goto)
-        puts_registered("#{address}: #{goto}", "an alias")
-      end
+      @base.add_alias(address, goto)
+      puts_registered("#{address}: #{goto}", "an alias")
+    end
+
+    def edit_account(address, options)
+      mailbox_check(address)
+      mailbox = Mailbox.find(address)
+      mailbox.quota = options[:quota] * KB_TO_MB if options[:quota]
+      mailbox.save or raise "Could not save Mailbox"
+
+      puts "Successfully updated #{address}"
+      show_account(address)
     end
 
     def delete_alias(address)
-      puts_deleted(address) if @base.delete_alias(address)
+      @base.delete_alias(address)
+      puts_deleted(address)
     end
 
     def delete_admin(user_name)
-      puts_deleted(user_name) if @base.delete_admin(user_name)
+      @base.delete_admin(user_name)
+      puts_deleted(user_name)
     end
 
     def delete_account(address)
-      puts_deleted(address) if @base.delete_account(address)
+      @base.delete_account(address)
+      puts_deleted(address)
     end
 
     private
 
+    def show_alias_base(title, addresses)
+      report(title, " No. Address                                  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]
+        end
+      end
+    end
+
     def puts_registered(name, as_str)
       puts %Q!"#{name}" was successfully registered as #{as_str}.!
     end
@@ -223,7 +285,7 @@ module PostfixAdmin
     end
 
     def config_file
-      config_file = File.expand_path(CONFIG_FILE)
+      config_file = File.expand_path(CLI.config_file)
     end
 
     def load_config
@@ -237,15 +299,15 @@ module PostfixAdmin
       end
     end
 
-    def create_config(config_file)
-      open(config_file, 'w') do |f|
-        f.write PostfixAdmin::Base::DEFAULT_CONFIG.to_yaml
+    def create_config(file)
+      open(file, 'w') do |f|
+        f.write Base::DEFAULT_CONFIG.to_yaml
       end
-      File.chmod(0600, config_file)
+      File.chmod(0600, file)
     end
 
     def print_line
-      puts "-"*100
+      puts "-"*120
     end
 
     def report(title, index=nil)
@@ -257,12 +319,29 @@ module PostfixAdmin
       print_line
     end
 
-    def domain_check(domain_name)
-      unless Domain.exist?(domain_name)
-        raise Error, %Q!Could not find domain "#{domain_name}"!
+    def account_check(user_name)
+      unless Mailbox.exist?(user_name) && Alias.exist?(user_name)
+        raise Error, %Q!Could not find account "#{user_name}"!
       end
     end
 
+    def domain_check(domain_name)
+      klass_check(Domain, domain_name)
+    end
+
+    def mailbox_check(address)
+      klass_check(Mailbox, 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)
+    end
+
     def validate_password(password)
       if password.size < MIN_NUM_PASSWORD_CHARACTER
         raise ArgumentError, "Password is too short. It should be larger than #{MIN_NUM_PASSWORD_CHARACTER}"
@@ -270,9 +349,8 @@ module PostfixAdmin
     end
 
     def change_password(klass, user_name, password)
-      unless klass.exist?(user_name)
-        raise Error, "Could not find #{user_name}"
-      end
+      raise Error, "Could not find #{user_name}" unless klass.exist?(user_name)
+
       validate_password(password)
 
       obj = klass.find(user_name)
@@ -284,5 +362,16 @@ module PostfixAdmin
       end
     end
 
+    def max_str(value)
+      case value
+      when 0
+        '--'
+      when -1
+        '0'
+      else
+        value.to_s
+      end
+    end
+
   end
 end