postfix_admin 0.2.1 → 0.3.0

data/lib/postfix_admin/base.rb

@@ -8,46 +8,41 @@ module PostfixAdmin
     attr_reader :config
 
     DEFAULT_CONFIG = {
-      'database'  => 'mysql2://postfix:password@localhost/postfix',
-      'aliases'   => 30,
-      'mailboxes' => 30,
-      'maxquota'  => 100,
-      'scheme'    => 'CRAM-MD5',
-      'passwordhash_prefix' => true
-    }
+      "database" => "mysql2://postfix:password@localhost/postfix",
+      "aliases" => 30,
+      "mailboxes" => 30,
+      "maxquota" => 100,
+      "scheme" => "CRAM-MD5",
+      "passwordhash_prefix" => true
+    }.freeze
 
     def initialize(config)
       @config = {}
-      @config[:database]  = config['database']
-      @config[:aliases]   = config['aliases']   || 30
-      @config[:mailboxes] = config['mailboxes'] || 30
-      @config[:maxquota]  = config['maxquota']  || 100
-      @config[:scheme]    = config['scheme']    || 'CRAM-MD5'
-      @config[:passwordhash_prefix] = if config['passwordhash_prefix'].nil?
-                                        true
+      @config[:database]  = config["database"]
+      @config[:aliases]   = config["aliases"]   || DEFAULT_CONFIG["aliases"]
+      @config[:mailboxes] = config["mailboxes"] || DEFAULT_CONFIG["mailboxes"]
+      @config[:maxquota]  = config["maxquota"]  || DEFAULT_CONFIG["maxquota"]
+      @config[:scheme]    = config["scheme"]    || DEFAULT_CONFIG["scheme"]
+      @config[:passwordhash_prefix] = if config.has_key?("passwordhash_prefix")
+                                        config["passwordhash_prefix"]
                                       else
-                                        config['passwordhash_prefix']
+                                        DEFAULT_CONFIG["passwordhash_prefix"]
                                       end
     end
 
     def db_setup
-      raise "'database' parameter is required in '#{CLI.config_file}'" unless @config[:database]
+      database = ENV.fetch("DATABASE_URL") { @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}'")
+      unless database
+        raise_error "'database' parameter is required in '#{CLI.config_file}' or specify 'DATABASE_URL' environment variable"
       end
 
-      if uri.scheme != "mysql2"
-        raise "'#{uri.scheme}' is not supported as a DB adopter. Use 'mysql2' instead in '#{CLI.config_file}'."
-      end
+      uri = URI.parse(database)
 
       ActiveRecord::Base.establish_connection(uri.to_s)
 
     rescue LoadError => e
-      raise e.message
+      raise_error e.message
     end
 
     def add_admin_domain(user_name, domain_name)
@@ -57,11 +52,11 @@ module PostfixAdmin
       domain = Domain.find(domain_name)
 
       if admin.has_domain?(domain)
-        raise Error, "#{user_name} is already registered as admin of #{domain_name}."
+        raise_error "Admin '#{user_name}' has already been registered for Domain '#{domain_name}'"
       end
 
       admin.rel_domains << domain
-      admin.save or raise "Relation Error: Domain of Admin"
+      admin.save || raise_error("Relation Error: Domain of Admin")
     end
 
     def delete_admin_domain(user_name, domain_name)
@@ -71,135 +66,116 @@ module PostfixAdmin
       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}."
+        raise_error "#{user_name} is not registered as admin of #{domain_name}."
       end
 
       domain_admin_query.delete_all
     end
 
     def add_admin(username, password)
-      password_check(password)
+      validate_password(password)
 
       if Admin.exists?(username)
-        raise Error, "#{username} is already registered as admin."
+        raise_error "Admin has already been registered: #{username}"
       end
+
       admin = Admin.new
       admin.attributes = {
         username: username,
-        password: password,
+        password: password
       }
-      unless admin.save
-        raise "Could not save Admin #{admin.errors.map(&:to_s).join}"
-      end
-    end
-
-    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.exists?(domain_name)
-        raise Error, "Could not find domain #{domain_name}"
-      end
+      raise_save_error(admin) unless admin.save
+    end
 
-      if Alias.exists?(address)
-        raise Error, "#{address} is already registered."
-      end
+    # Adds an email account that consists of a Mailbox and an Alias.
+    def add_account(address, password, name: "")
+      validate_account(address, password)
 
-      domain = Domain.find(domain_name)
+      local_part, domain_name = address_split(address)
+      domain_must_exist!(domain_name)
 
       attributes = {
-          username: address,
-          password: password,
-          name: name,
-          maildir: path,
-          local_part: user,
-          quota_mb: @config[:maxquota]
+        local_part: local_part,
+        domain: domain_name,
+        password: password,
+        name: name,
+        quota_mb: @config[:maxquota]
       }
 
+      # An Alias also will be added when a Mailbox is saved.
       mailbox = Mailbox.new(attributes)
 
-      domain.rel_mailboxes << mailbox
-
-      unless domain.save
-        raise "Could not save Mailbox and Domain #{mailbox.errors.map(&:to_s).join} #{domain.errors.map(&:to_s).join}"
-      end
+      raise_save_error(mailbox) unless mailbox.save
     end
 
     def add_alias(address, goto)
       if Mailbox.exists?(address)
-        raise Error, "mailbox #{address} is already registered!"
-      end
-      if Alias.exists?(address)
-        raise Error, "alias #{address} is already registered!"
+        raise_error "Mailbox has already been registered: #{address}"
       end
 
-      local_part, domain_name = address_split(address)
+      alias_must_not_exist!(address)
 
-      unless Domain.exists?(domain_name)
-        raise Error, "Invalid domain! #{domain_name}"
-      end
+      local_part, domain_name = address_split(address)
 
-      domain = Domain.find(domain_name)
+      domain = find_domain(domain_name)
 
       attributes = {
         local_part: local_part,
         goto: goto
       }
+
       domain.rel_aliases << Alias.new(attributes)
-      domain.save or raise "Could not save Alias"
+
+      raise_save_error(domain) unless domain.save
     end
 
     def delete_alias(address)
       if Mailbox.exists?(address)
-        raise Error, "Can not delete mailbox by delete_alias. Use delete_account"
+        raise_error "Can not delete mailbox by delete_alias. Use delete_account"
       end
 
       unless Alias.exists?(address)
-        raise Error, "#{address} is not found!"
+        raise_error "#{address} is not found!"
       end
 
       Alias.where(address: address).delete_all
     end
 
-    def add_domain(domain_name)
+    def add_domain(domain_name, description: nil)
       domain_name = domain_name.downcase
-      if domain_name !~ /.+\..+/
-        raise Error, "Ivalid domain! #{domain_name}"
+
+      unless valid_domain_name?(domain_name)
+        raise_error "Invalid domain name: #{domain_name}"
       end
+
       if Domain.exists?(domain_name)
-        raise Error, "#{domain_name} is already registered!"
+        raise_error "Domain has already been registered: #{domain_name}"
       end
+
+      new_description = description || domain_name
+
       domain = Domain.new
       domain.attributes = {
         domain: domain_name,
-        description: domain_name,
+        description: new_description,
         aliases: @config[:aliases],
         mailboxes: @config[:mailboxes],
-        maxquota: @config[:maxquota],
+        maxquota: @config[:maxquota]
       }
       domain.save!
     end
 
     def delete_domain(domain_name)
       domain_name = domain_name.downcase
-      unless Domain.exists?(domain_name)
-        raise Error, "Could not find domain #{domain_name}"
-      end
 
-      domain = Domain.find(domain_name)
-      domain.rel_mailboxes.delete_all
-      domain.rel_aliases.delete_all
+      domain = find_domain(domain_name)
 
       admin_names = domain.admins.map(&:username)
 
-      domain.admins.delete_all
+      domain.destroy!
 
+      # Remove admins who had the deleted domain only
       admin_names.each do |name|
         next unless Admin.exists?(name)
 
@@ -207,16 +183,14 @@ module PostfixAdmin
 
         # check if the admin is needed or not
         if admin.rel_domains.empty?
-          admin.destroy
+          admin.destroy!
         end
       end
-
-      domain.destroy
     end
 
     def delete_admin(user_name)
       unless Admin.exists?(user_name)
-        raise Error, "Could not find admin #{user_name}"
+        raise_error "Could not find admin #{user_name}"
       end
 
       admin = Admin.find(user_name)
@@ -226,26 +200,72 @@ module PostfixAdmin
 
     def delete_account(address)
       unless Alias.exists?(address) && Mailbox.exists?(address)
-        raise Error, "Could not find account #{address}"
+        raise_error "Could not find account: #{address}"
       end
 
       Mailbox.where(username: address).delete_all
       Alias.where(address: address).delete_all
     end
 
+    private
+
+    def find_domain(domain_name)
+      domain_must_exist!(domain_name)
+      Domain.find(domain_name)
+    end
+
+    def raise_error(message)
+      raise PostfixAdmin::Error, message
+    end
+
+    def raise_save_error(obj)
+      raise_error "Failed to save #{obj.class}: #{obj.errors.full_messages.join(', ')}"
+    end
+
     def address_split(address)
       address.split('@')
     end
 
-    private
+    def valid_domain_name?(domain_name)
+      /.+\..+/.match?(domain_name)
+    end
+
+    def valid_email_address?(address)
+      /.+@.+\..+/.match?(address)
+    end
+
+    def domain_must_exist!(domain_name)
+      unless Domain.exists?(domain_name)
+        raise_error "Could not find domain: #{domain_name}"
+      end
+    end
+
+    def alias_must_not_exist!(address)
+      if Alias.exists?(address)
+        raise_error "Alias has already been registered: #{address}"
+      end
+    end
 
     def admin_domain_check(user_name, 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)
+      unless Admin.exists?(user_name)
+        raise_error "#{user_name} is not registered as admin."
+      end
+
+      domain_must_exist!(domain_name)
+    end
+
+    def validate_password(password)
+      raise_error "Empty password" if password.nil? || password.empty?
     end
 
-    def password_check(password)
-      raise Error, "Empty password" if password.nil? || password.empty?
+    def validate_account(address, password)
+      validate_password(password)
+
+      unless valid_email_address?(address)
+        raise_error "Invalid email address: #{address}"
+      end
+
+      alias_must_not_exist!(address)
     end
   end
 end