postfix_admin 0.1.4 → 0.2.0

data/lib/postfix_admin/doveadm.rb

@@ -16,7 +16,7 @@ module PostfixAdmin
       if stderr.readlines.to_s =~ /Fatal:/
         raise Error, stderr.readlines
       else
-        stdout.readlines.first.chomp.gsub("{#{scheme}}", "")
+        stdout.readlines.first.chomp
       end
     end
 

data/lib/postfix_admin/log.rb

@@ -0,0 +1,5 @@
+module PostfixAdmin
+  class Log < ApplicationRecord
+    self.table_name = :log
+  end
+end

data/lib/postfix_admin/mail_domain.rb

@@ -0,0 +1,9 @@
+module PostfixAdmin
+  class MailDomain < ApplicationRecord
+    self.table_name = :domain
+    self.primary_key = :domain
+
+    has_many :addresses, class_name: "Mailbox", foreign_key: :domain,
+                         dependent: :destroy
+  end
+end

data/lib/postfix_admin/mailbox.rb

@@ -0,0 +1,89 @@
+module PostfixAdmin
+  class Mailbox < ApplicationRecord
+    self.table_name = :mailbox
+    self.primary_key = :username
+
+    include DovecotCramMD5Password
+
+    attribute :quota_mb, :integer
+
+    validates :username, presence: true, uniqueness: { case_sensitive: false },
+                         format: { with: RE_EMAIL_LIKE_WITH_ANCHORS,
+                                   message: "must be a valid email address" }
+    validates :maildir, presence: true, uniqueness: { case_sensitive: false }
+    validates :local_part, presence: true
+    validates :quota, presence: true,
+                      numericality: { only_integer: true,
+                                      greater_than_or_equal_to: 0 }
+    validates :quota_mb, presence: true,
+                         numericality: { only_integer: true,
+                                         greater_than_or_equal_to: 0 }
+
+    belongs_to :rel_domain, class_name: "Domain", foreign_key: :domain
+    has_one :alias, foreign_key: :address, dependent: :destroy
+    has_one :quota_usage, class_name: "Quota", foreign_key: :username,
+            dependent: :destroy
+
+    validate on: :create do |mailbox|
+      domain = mailbox.rel_domain
+      if !domain.mailboxes.zero? && domain.rel_mailboxes.count >= domain.mailboxes
+        message = "already has the maximum number of mailboxes " \
+                  "(maximum is #{domain.mailboxes} mailboxes)"
+        mailbox.errors.add(:domain, message)
+      end
+    end
+
+    # just in case
+    validate on: :update do |mailbox|
+      mailbox.errors.add(:username, 'cannot be changed') if mailbox.username_changed?
+      mailbox.errors.add(:local_part, 'cannot be changed') if mailbox.local_part_changed?
+    end
+
+    validate do |mailbox|
+      domain = mailbox.rel_domain
+
+      unless domain.maxquota.zero?
+        if mailbox.quota_mb.zero?
+          mailbox.errors.add(:quota_mb, "cannot be 0")
+        elsif mailbox.quota_mb > domain.maxquota
+          message = "must be less than or equal to #{domain.maxquota} (MB)"
+          mailbox.errors.add(:quota_mb, message)
+        end
+      end
+    end
+
+    before_validation do |mailbox|
+      mailbox.name = "" if mailbox.name.nil?
+      if mailbox.quota_mb
+        mailbox.quota = mailbox.quota_mb * KB_TO_MB
+      elsif mailbox.quota
+        mailbox.quota_mb = mailbox.quota / KB_TO_MB
+      else
+        mailbox.quota_mb = 0
+        mailbox.quota = 0
+      end
+      mailbox.username = "#{mailbox.local_part}@#{mailbox.domain}"
+      mailbox.maildir = "#{mailbox.domain}/#{mailbox.username}/"
+      mailbox.build_alias(local_part: mailbox.local_part, goto: mailbox.username,
+                          domain: mailbox.domain)
+    end
+
+    def quota_usage_str
+      if quota_usage
+        usage_mb = quota_usage.bytes / KB_TO_MB
+        usage_mb.to_s
+      else
+        "0"
+      end
+    end
+
+    def quota_str
+      if quota.zero?
+        "--"
+      else
+        quota_mb = quota / KB_TO_MB
+        "#{quota_mb} MB"
+      end
+    end
+  end
+end

data/lib/postfix_admin/models.rb

@@ -1,213 +1,10 @@
-require 'data_mapper'
-
-module PostfixAdmin
-  def self.flag_str(flag)
-    flag ? "YES" : "NO"
-  end
-
-  class Config
-    include ::DataMapper::Resource
-    property :id,    Integer, :key => true
-    property :name,  String
-    property :value, String
-    storage_names[:default] = 'config'
-  end
-
-  class Admin
-    include ::DataMapper::Resource
-    property :username, String, :key => true, :length => 0..255
-    property :password, String, :length => 0..255
-    property :active, Boolean, :default  => true
-    property :created, DateTime, :default => DateTime.now
-    property :modified, DateTime, :default => DateTime.now
-
-    has n, :domain_admins, :child_key => :username
-    has n, :domains, :model => 'Domain', :through => :domain_admins, :via => :domain
-    storage_names[:default] = 'admin'
-
-    def active_str
-      PostfixAdmin.flag_str(active)
-    end
-
-    def has_domain?(domain_name)
-      if super_admin?
-        Domain.exist?(domain_name)
-      else
-        exist_domain?(domain_name)
-      end
-    end
-
-    def super_admin=(value)
-      if value
-        domains << Domain.find('ALL')
-        save or raise "Could not save ALL domain for Admin"
-      else
-        domain_admins(:domain_name => 'ALL').destroy or raise "Could not destroy DoaminAdmin for Admin"
-      end
-    end
-
-    def super_admin?
-      exist_domain?('ALL')
-    end
-
-    def clear_domains
-      domains.clear
-      save or raise "Could save Admin"
-    end
-
-    def self.find(username)
-      Admin.first(:username => username)
-    end
-
-    def self.exist?(username)
-      !!Admin.find(username)
-    end
-
-    private
-
-    def exist_domain?(domain_name)
-      !!domains.first(:domain_name => domain_name)
-    end
-  end
-
-  class Domain
-    include ::DataMapper::Resource
-    property :domain_name, String, :field => 'domain', :key => true, :length => 0..255
-    property :maxaliases, Integer, :field => 'aliases'
-    property :maxmailboxes, Integer, :field => 'mailboxes'
-    property :maxquota, Integer
-    property :transport, String, :default => 'virtual', :length => 0..255
-    property :backupmx, Integer, :default => 0
-    property :description, String, :length => 0..255
-    property :active, Boolean, :default  => true
-    property :created,  DateTime, :default => DateTime.now
-    property :modified, DateTime, :default => DateTime.now
-
-    has n, :domain_admins, :child_key => :domain_name
-    has n, :admins, :model => 'Admin', :through => :domain_admins
-
-    has n, :mailboxes, :model => 'Mailbox', :child_key => :domain_name
-    has n, :aliases, :model => 'Alias', :child_key => :domain_name
-    storage_names[:default] = 'domain'
-
-    def self.all_without_special_domain
-      Domain.all(:domain_name.not => 'ALL')
-    end
-
-    def self.find(domain)
-      Domain.first(:domain_name => domain)
-    end
-
-    def self.exist?(domain)
-      !!Domain.find(domain)
-    end
-
-    def self.num_total_aliases
-      Alias.count - Mailbox.count
-    end
-
-    def num_total_aliases
-      aliases.count - mailboxes.count
-    end
-
-    def clear_admins
-      admins.clear
-      save or raise "Could not save Domain"
-    end
-
-    def active_str
-      PostfixAdmin.flag_str(active)
-    end
-  end
-
-  class DomainAdmin
-    include ::DataMapper::Resource
-    property :created, DateTime, :default => DateTime.now
-    property :domain_name, String, :field => 'domain', :key => true, :length => 0..255
-    property :username, String, :key => true, :length => 0..255
-
-    belongs_to :domain, :model => 'Domain', :child_key => :domain_name
-    belongs_to :admin, :model => 'Admin', :child_key => :username
-    storage_names[:default] = 'domain_admins'
-  end
-
-  class Mailbox
-    include ::DataMapper::Resource
-    property :username, String, :key => true, :length => 0..255
-    property :name, String, :length => 0..255
-    property :domain_name, String, :field => 'domain'
-    property :password, String, :length => 0..255
-    property :maildir, String, :length => 0..255
-    property :quota, Integer
-    property :active, Boolean, :default  => true
-    property :created, DateTime, :default => DateTime.now
-    property :modified, DateTime, :default => DateTime.now
-
-    belongs_to :domain, :model => 'Domain', :child_key => :domain_name
-
-    storage_names[:default] = 'mailbox'
-    def active_str
-      PostfixAdmin.flag_str(active)
-    end
-
-    def self.find(username)
-      Mailbox.first(:username => username)
-    end
-
-    def self.exist?(username)
-      !!Mailbox.find(username)
-    end
-  end
-
-  class Alias
-    include ::DataMapper::Resource
-    property :address, String, :key => true, :length => 0..255
-    property :goto, Text
-    property :domain_name, String, :field => 'domain', :length => 0..255
-    property :active, Boolean, :default  => true
-    property :created, DateTime, :default => DateTime.now
-    property :modified, DateTime, :default => DateTime.now
-
-    belongs_to :domain, :model => 'Domain', :child_key => :domain_name
-
-    storage_names[:default] = 'alias'
-
-    def active_str
-      PostfixAdmin.flag_str(active)
-    end
-
-    def self.mailbox(address)
-      mail_alias = Alias.new
-      mail_alias.attributes = {
-        :address     => address,
-        :goto        => address,
-      }
-      mail_alias
-    end
-
-    def self.find(address)
-      Alias.first(:address => address)
-    end
-
-    def self.exist?(address)
-      !!Alias.find(address)
-    end
-
-    def mailbox?
-      Mailbox.exist?(address)
-    end
-  end
-
-  class Log
-    include ::DataMapper::Resource
-    property :timestamp, DateTime, key: true, default: DateTime.now
-    property :username, String, length: 0..255
-    property :domain_name, String, field: 'domain', length: 0..255
-    property :action, String, length: 0..255
-    property :data, Text
-
-    belongs_to :domain, :model => 'Domain', :child_key => :domain_name
-
-    storage_names[:default] = 'log'
-  end
-end
+require 'active_record'
+require 'postfix_admin/application_record'
+require 'postfix_admin/admin'
+require 'postfix_admin/domain'
+require 'postfix_admin/mailbox'
+require 'postfix_admin/alias'
+require 'postfix_admin/domain_admin'
+require 'postfix_admin/log'
+require 'postfix_admin/mail_domain'
+require 'postfix_admin/quota'

data/lib/postfix_admin/quota.rb

@@ -0,0 +1,6 @@
+module PostfixAdmin
+  class Quota < ApplicationRecord
+    self.table_name = :quota2
+    self.primary_key = :username
+  end
+end

data/lib/postfix_admin/runner.rb

@@ -5,50 +5,54 @@ require 'postfix_admin/doveadm'
 
 module PostfixAdmin
   class Runner < Thor
+    def self.exit_on_failure?
+      true
+    end
+
     def initialize(*args)
       super
       @cli = CLI.new
     end
 
     desc "summary [example.com]", "Summarize the usage of PostfixAdmin"
-    def summary(domain_name=nil)
-      runner{ @cli.show_summary(domain_name) }
+    def summary(domain_name = nil)
+      runner { @cli.show_summary(domain_name) }
     end
 
     desc "schemes", "List all supported password schemes"
     def schemes
-      runner{ puts PostfixAdmin::Doveadm.schemes.join(' ') }
+      runner { puts PostfixAdmin::Doveadm.schemes.join(' ') }
     end
 
     desc "show [example.com | admin@example.com | user@example.com]", "Show domains or admins or mailboxes"
-    def show(name=nil)
-      runner{ @cli.show(name) }
+    def show(name = nil)
+      runner { @cli.show(name) }
     end
 
     desc "setup example.com password", "Setup a domain"
     def setup(domain_name, password)
-      runner{ @cli.setup_domain(domain_name, password) }
+      runner { @cli.setup_domain(domain_name, password) }
     end
 
     desc "admin_passwd admin@example.com new_password", "Change password of admin"
     def admin_passwd(user_name, password)
-      runner{ @cli.change_admin_password(user_name, password) }
+      runner { @cli.change_admin_password(user_name, password) }
     end
 
     desc "account_passwd user@example.com new_password", "Change password of account"
     def account_passwd(user_name, password)
-      runner{ @cli.change_account_password(user_name, password) }
+      runner { @cli.change_account_password(user_name, password) }
     end
 
     desc "add_domain example.com", "Add a domain"
     def add_domain(domain_name)
-      runner{ @cli.add_domain(domain_name) }
+      runner { @cli.add_domain(domain_name) }
     end
 
     desc "edit_domain example.com", "Edit a domain limitation"
-    method_option :aliases,   :type => :numeric, :aliases => "-a", :desc => "Edit aliases limitation"
-    method_option :mailboxes, :type => :numeric, :aliases => "-m", :desc => "Edit mailboxes limitation"
-    method_option :maxquota,  :type => :numeric, :aliases => "-q", :desc => "Edit max quota limitation"
+    method_option :aliases,   type: :numeric, aliases: "-a", desc: "Edit aliases limitation"
+    method_option :mailboxes, type: :numeric, aliases: "-m", desc: "Edit mailboxes limitation"
+    method_option :maxquota,  type: :numeric, aliases: "-q", desc: "Edit max quota limitation"
     method_option :active, type: :boolean, desc: "Update active status"
     def edit_domain(domain_name)
       runner do
@@ -63,22 +67,22 @@ module PostfixAdmin
 
     desc "delete_domain example.com", "Delete a domain"
     def delete_domain(domain_name)
-      runner{ @cli.delete_domain(domain_name) }
+      runner { @cli.delete_domain(domain_name) }
     end
 
     desc "delete_admin admin@example.com", "Delete an admin"
     def delete_admin(user_name)
-      runner{ @cli.delete_admin(user_name) }
+      runner { @cli.delete_admin(user_name) }
     end
 
     desc "delete_account user@example.com", "Delete an account"
     def delete_account(address)
-      runner{ @cli.delete_account(address) }
+      runner { @cli.delete_account(address) }
     end
 
     desc "add_account user@example.com password", "Add an account"
-    method_option :scheme, :type => :string, :aliases => "-s", :desc => "password scheme"
-    method_option :name,   :type => :string, :aliases => "-n", :desc => "full name"
+    method_option :scheme, type: :string, aliases: "-s", desc: "password scheme"
+    method_option :name,   type: :string, aliases: "-n", desc: "full name"
     def add_account(address, password)
       runner do
         if options[:scheme] == 'scheme'
@@ -96,9 +100,9 @@ module PostfixAdmin
     end
 
     desc "edit_account user@example.com", "Edit an account"
-    method_option :goto,  :type => :string,  :aliases => "-g", :desc => "mailboxes, addresses e-mails are delivered to"
-    method_option :quota, :type => :numeric, :aliases => "-q", :desc => "quota limitation (MB)"
-    method_option :name,  :type => :string,  :aliases => "-n", :desc => "full name"
+    method_option :goto,  type: :string,  aliases: "-g", desc: "mailboxes, addresses e-mails are delivered to"
+    method_option :quota, type: :numeric, aliases: "-q", desc: "quota limitation (MB)"
+    method_option :name,  type: :string,  aliases: "-n", desc: "full name"
     method_option :active, type: :boolean, desc: "Update active status"
     def edit_account(address)
       runner do
@@ -131,8 +135,8 @@ module PostfixAdmin
     end
 
     desc "add_admin admin@example.com password", "Add an admin user"
-    method_option :super, :type => :boolean, :aliases => "-S", :desc => "register as a super admin"
-    method_option :scheme, :type => :string, :aliases => "-s", :desc => "password scheme"
+    method_option :super, type: :boolean, aliases: "-S", desc: "register as a super admin"
+    method_option :scheme, type: :string, aliases: "-s", desc: "password scheme"
     def add_admin(user_name, password)
       runner do
         if options[:scheme] == 'scheme'
@@ -146,17 +150,17 @@ module PostfixAdmin
 
     desc "add_admin_domain admin@example.com example.com", "Add admin_domain"
     def add_admin_domain(user_name, domain_name)
-      runner{ @cli.add_admin_domain(user_name, domain_name) }
+      runner { @cli.add_admin_domain(user_name, domain_name) }
     end
 
     desc "delete_admin_domain admin@example.com example.com", "Delete admin_domain"
     def delete_admin_domain(user_name, domain_name)
-      runner{ @cli.delete_admin_domain(user_name, domain_name) }
+      runner { @cli.delete_admin_domain(user_name, domain_name) }
     end
 
     desc "edit_alias alias@example.com", "Edit an alias"
-    method_option :goto,  :type => :string,  :aliases => "-g",
-                  :desc => "mailboxes, addresses e-mails are delivered to"
+    method_option :goto,  type: :string,  aliases: "-g",
+                  desc: "mailboxes, addresses e-mails are delivered to"
     method_option :active, type: :boolean, desc: "Update active status"
     def edit_alias(address)
       runner do
@@ -171,38 +175,37 @@ module PostfixAdmin
 
     desc "add_alias alias@example.com goto@example.net", "Add an alias"
     def add_alias(address, goto)
-      runner{ @cli.add_alias(address, goto) }
+      runner { @cli.add_alias(address, goto) }
     end
 
     desc "delete_alias alias@example.com", "Delete an alias"
     def delete_alias(address)
-      runner{ @cli.delete_alias(address) }
+      runner { @cli.delete_alias(address) }
     end
 
     desc "log", "Show action logs"
     def log
-      runner{ @cli.log }
+      runner { @cli.log }
     end
 
     desc "dump", "Dump all data"
     def dump
-      runner{ @cli.dump }
+      runner { @cli.dump }
     end
 
     desc "version", "Show postfix_admin version"
     def version
       require 'postfix_admin/version'
-      runner{ say "postfix_admin #{VERSION}" }
+      runner { say "postfix_admin #{VERSION}" }
     end
 
     private
 
     def runner
-      begin
-        yield
-      rescue Error, ArgumentError => e
-        abort e.message
-      end
+      @cli.db_setup
+      yield
+    rescue StandardError => e
+      abort "Error: #{e.message}"
     end
   end
 end