cli.rb in postfix_admin-0.2.0

- old
+ new

@@ -18,21 +18,25 @@
 
     def self.config_file=(value)
       @config_file = value
     end
 
+    def db_setup
+      @base.db_setup
+    end
+
     def show(name)
       name = name.downcase if name
 
       if name =~ /@/
-        if Admin.exist?(name)
+        if Admin.exists?(name)
           show_admin_details(name)
         end
 
-        if Mailbox.exist?(name)
+        if Mailbox.exists?(name)
           show_account_details(name)
-        elsif Alias.exist?(name)
+        elsif Alias.exists?(name)
           show_alias_details(name)
         end
 
         return
       end
@@ -47,30 +51,30 @@
         show_domain
         show_admin
       end
     end
 
-    def show_summary(domain_name=nil)
+    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.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
 
     def setup_domain(domain_name, password)
@@ -100,11 +104,11 @@
       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.domains.count)
+        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
 
@@ -119,22 +123,21 @@
     end
 
     def show_domain
       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|
+        Domain.without_all.each_with_index do |d, i|
           puts "%4d %-30s %3d /%3s   %3d /%3s %10d         %-3s" %
-            [i+1, d.domain_name, d.num_total_aliases, max_str(d.maxaliases),
-             d.mailboxes.count, max_str(d.maxmailboxes), d.maxquota, d.active_str]
+            [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)
       @base.add_domain(domain_name)
       puts_registered(domain_name, "a domain")
@@ -149,57 +152,60 @@
     end
 
     def edit_admin(admin_name, options)
       admin_check(admin_name)
       admin = Admin.find(admin_name)
-      admin.super_admin = options[:super] unless options[:super].nil?
+
+      unless options[:super].nil?
+        admin.super_admin = options[:super]
+      end
+
       admin.active = options[:active] unless options[:active].nil?
-      admin.save or raise "Could not save Admin"
+      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.active       = options[:active] unless options[:active].nil?
-      domain.save or raise "Could not save Domain"
+      domain.save!
 
       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_name=nil)
-      admins = domain_name ? Admin.select{|a| a.has_domain?(domain_name)} : Admin.all
+    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
 
         admins.each_with_index do |a, i|
-          domains = a.super_admin? ? 'Super admin' : a.domains.count
+          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
+      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
@@ -208,17 +214,16 @@
         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
       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
       end
 
@@ -226,23 +231,23 @@
       show_alias_base("Aliases",  aliases)
     end
 
     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, scheme=nil)
+    def add_admin(user_name, password, super_admin = false, scheme = nil)
       validate_password(password)
 
       @base.add_admin(user_name, hashed_password(password, scheme))
       if super_admin
         Admin.find(user_name).super_admin = true
@@ -260,11 +265,11 @@
     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, scheme=nil, name=nil)
+    def add_account(address, password, scheme = nil, name = nil)
       validate_password(password)
 
       @base.add_account(address, hashed_password(password, scheme), name)
       puts_registered(address, "an account")
       show_account_details(address)
@@ -279,16 +284,16 @@
       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.active = options[:active] unless options[:active].nil?
-      mailbox.save or raise "Could not save Mailbox"
+      mailbox.save!
 
       if options[:goto]
         mail_alias = Alias.find(address)
         mail_alias.goto = options[:goto]
-        mail_alias.save or raise "Could not save Alias"
+        mail_alias.save!
       end
 
       puts "Successfully updated #{address}"
       show_account_details(address)
     end
@@ -320,11 +325,11 @@
     end
 
     def log
       Log.all.each do |l|
         time = l.timestamp.strftime("%Y-%m-%d %X %Z")
-        puts "#{time}  #{l.username}  #{l.domain_name}  #{l.action}  #{l.data}"
+        puts "#{time}  #{l.username}  #{l.domain}  #{l.action}  #{l.data}"
       end
     end
 
     def dump
       puts "Admins"
@@ -333,29 +338,29 @@
         puts [a.username, %Q!"#{a.password}"!, a.super_admin?, a.active].join(',')
       end
       puts
       puts "Domains"
       puts "Domain Name,Max Quota,Active"
-      Domain.all_without_special_domain.each do |d|
-        puts [d.domain_name, d.maxquota, d.active].join(',')
+      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|
+      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|
+      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
@@ -405,21 +410,21 @@
 
     def print_line
       puts "-"*120
     end
 
-    def report(title, index=nil)
+    def report(title, index = nil)
       puts "\n[#{title}]"
       print_line if index
       puts index if index
       print_line
       yield
       print_line
     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
 
     def domain_check(domain_name)
@@ -438,27 +443,27 @@
       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)
       if password.size < MIN_NUM_PASSWORD_CHARACTER
         raise ArgumentError, "Password is too short. It should be larger than #{MIN_NUM_PASSWORD_CHARACTER}"
       end
     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 = hashed_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}"
       end
     end
@@ -474,13 +479,12 @@
       end
     end
 
     private
 
-    def hashed_password(password, in_scheme=nil)
+    def hashed_password(password, in_scheme = nil)
       scheme = in_scheme || @base.config[:scheme]
       puts "scheme: #{scheme}"
       PostfixAdmin::Doveadm.password(password, scheme)
     end
-
   end
 end