postfix_admin 0.1.4 → 0.2.0

data/lib/postfix_admin/cli.rb

@@ -20,17 +20,21 @@ module PostfixAdmin
       @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
 
@@ -49,7 +53,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
@@ -60,15 +64,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
@@ -102,7 +106,7 @@ module PostfixAdmin
       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
@@ -121,18 +125,17 @@ module PostfixAdmin
     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)
@@ -151,9 +154,13 @@ module PostfixAdmin
     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)
@@ -162,11 +169,11 @@ module PostfixAdmin
     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)
@@ -177,8 +184,8 @@ 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
+    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?
@@ -187,17 +194,16 @@ module PostfixAdmin
         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?
@@ -210,13 +216,12 @@ module PostfixAdmin
           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
@@ -228,19 +233,19 @@ 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, 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))
@@ -262,7 +267,7 @@ 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, scheme = nil, name = nil)
       validate_password(password)
 
       @base.add_account(address, hashed_password(password, scheme), name)
@@ -281,12 +286,12 @@ module PostfixAdmin
       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}"
@@ -322,7 +327,7 @@ module PostfixAdmin
     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
 
@@ -335,8 +340,8 @@ module PostfixAdmin
       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"
@@ -347,13 +352,13 @@ module PostfixAdmin
       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
@@ -407,7 +412,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
@@ -417,7 +422,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
@@ -440,7 +445,7 @@ module PostfixAdmin
 
     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)
@@ -450,13 +455,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 = 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}"
@@ -476,11 +481,10 @@ module PostfixAdmin
 
     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

data/lib/postfix_admin/concerns/dovecot_cram_md5_password.rb

@@ -0,0 +1,30 @@
+require 'active_support/concern'
+
+module DovecotCramMD5Password
+  extend ActiveSupport::Concern
+
+  included do
+    validates :password_unencrypted, length: { minimum: 5 }, allow_blank: true
+    validates_confirmation_of :password_unencrypted, allow_blank: true
+
+    validate do |record|
+      record.errors.add(:password_unencrypted, :blank) unless record.password.present?
+    end
+
+    attr_reader :password_unencrypted
+    attr_accessor :password_unencrypted_confirmation
+  end
+
+  def password_unencrypted=(unencrypted_password)
+    if unencrypted_password.nil?
+      self.password = nil
+    elsif !unencrypted_password.empty?
+      @password_unencrypted = unencrypted_password
+      self.password = DovecotCrammd5.calc(unencrypted_password)
+    end
+  end
+
+  def authenticate(unencrypted_password)
+    password == DovecotCrammd5.calc(unencrypted_password) && self
+  end
+end

data/lib/postfix_admin/concerns/existing_timestamp.rb

@@ -0,0 +1,18 @@
+require 'active_support/concern'
+
+module ExistingTimestamp
+  extend ActiveSupport::Concern
+
+  class_methods do
+    private
+
+    def timestamp_attributes_for_create
+      ["created"]
+    end
+
+    def timestamp_attributes_for_update
+      ["modified"]
+    end
+  end
+
+end

data/lib/postfix_admin/domain.rb

@@ -0,0 +1,98 @@
+module PostfixAdmin
+  class Domain < ApplicationRecord
+    self.table_name = :domain
+    self.primary_key = :domain
+
+    validates :domain, presence: true, uniqueness: { case_sensitive: false },
+                       format: { with: RE_DOMAIN_NAME_LIKE_WITH_ANCHORS,
+                                 message: "must be a valid domain name" }
+    validates :transport, presence: true
+
+    validates :aliases, presence: true,
+                        numericality: { only_integer: true,
+                                        greater_than_or_equal_to: 0 }
+    validates :mailboxes, presence: true,
+                          numericality: { only_integer: true,
+                                          greater_than_or_equal_to: 0 }
+    validates :maxquota, presence: true,
+                         numericality: { only_integer: true,
+                                         greater_than_or_equal_to: 0 }
+
+    has_many :rel_mailboxes, class_name: "Mailbox", foreign_key: :domain,
+                             dependent: :destroy
+    has_many :rel_aliases, class_name: "Alias", foreign_key: :domain,
+                           dependent: :destroy
+
+    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.transport = "virtual"
+    end
+
+    scope :without_all, -> { where.not(domain: "ALL") }
+
+    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)
+    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)
+    end
+
+    def maxquota_str
+      if maxquota.zero?
+        "Unlimited"
+      else
+        "#{maxquota} MB"
+      end
+    end
+
+    def maxquota_short_str
+      if maxquota.zero?
+        "--"
+      else
+        "#{maxquota} MB"
+      end
+    end
+
+    private
+
+    def num_str(num)
+      if num.zero?
+        "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/domain_admin.rb

@@ -0,0 +1,8 @@
+module PostfixAdmin
+  class DomainAdmin < ApplicationRecord
+    self.table_name = :domain_admins
+
+    belongs_to :admin, primary_key: :username, foreign_key: :username
+    belongs_to :rel_domain, class_name: "Domain", foreign_key: :domain
+  end
+end