postfix_admin 0.0.2 → 0.1.0

data/lib/postfix_admin/error.rb

@@ -0,0 +1,4 @@
+module PostfixAdmin
+  class Error < StandardError
+  end
+end

data/lib/postfix_admin/models.rb

@@ -1,35 +1,125 @@
 require 'data_mapper'
 
-class PostfixAdmin
+#
+# This extension is to avoid 'ArgumentError: invalid date' when datetime value of
+# MySQL is '0000-00-00 00:00:00'.
+#
+class DateTime
+  class << self
+
+    alias org_new new
+    def new(year = -4712, mon = 1, mday = 1, hour = 0, min = 0, sec = 0, offset = 0, start = Date::ITALY)
+      if year == 0
+        nil
+      else
+        org_new(year, mon, mday, hour, min, sec, offset, start)
+      end
+    end
+  end
+end
+
+module PostfixAdmin
   class Admin
     include ::DataMapper::Resource
     property :username, String, :key => true
     property :password, String
-    property :created, DateTime
-    property :modified, DateTime
+    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 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 self.find(username)
+      Admin.first(:username => username)
+    end
+
+    def self.exist?(username)
+      !!Admin.find(username)
+    end
+
+    def self.unnecessary
+      all.delete_if do |admin|
+        admin.domains.size > 0
+      end
+    end
+
+    private
+
+    def exist_domain?(domain_name)
+      !!domains.first(:domain_name => domain_name)
+    end
   end
 
   class Domain
     include ::DataMapper::Resource
-    property :domain, String, :key => true
-    property :aliases, Integer
-    property :mailboxes, Integer
+    property :domain_name, String, :field => 'domain', :key => true
+    property :maxaliases, Integer, :field => 'aliases'
+    property :maxmailboxes, Integer, :field => 'mailboxes'
     property :maxquota, Integer
-    property :transport, String
-    property :backupmx, Integer
+    property :transport, String, :default => 'virtual'
+    property :backupmx, Integer, :default => 0
     property :description, String
+    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
   end
 
   class DomainAdmin
     include ::DataMapper::Resource
+    property :created, DateTime, :default => DateTime.now
+    property :domain_name, String, :field => 'domain', :key => true
     property :username, String, :key => true
-    property :domain, String, :key => true
-    property :created, DateTime
 
+    belongs_to :domain, :model => 'Domain', :child_key => :domain_name
+    belongs_to :admin, :model => 'Admin', :child_key => :username
     storage_names[:default] = 'domain_admins'
   end
 
@@ -37,25 +127,45 @@ class PostfixAdmin
     include ::DataMapper::Resource
     property :username, String, :key => true
     property :name, String
+    property :domain_name, String, :field => 'domain'
     property :password, String
-    property :domain, String
     property :maildir, String
     property :quota, Integer
     #  property :local_part, String
-    property :created, DateTime
-    property :modified, DateTime
+    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 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
-    property :goto, Text, :key => true
-    property :domain, String
-    property :created, DateTime
-    property :modified, DateTime
+    property :goto, Text
+    property :domain_name, String, :field => 'domain'
+    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 self.find(address)
+      Alias.first(:address => address)
+    end
+
+    def self.exist?(address)
+      !!Alias.find(address)
+    end
   end
 end

data/lib/postfix_admin/runner.rb

@@ -0,0 +1,105 @@
+require 'thor'
+require 'postfix_admin'
+require 'postfix_admin/cli'
+
+module PostfixAdmin
+  class Runner < Thor
+    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) }
+    end
+
+    desc "show [example.com]", "List of domains"
+    def show(domain_name=nil)
+      runner{ @cli.show(domain_name) }
+    end
+
+    desc "setup example.com password", "Setup a domain"
+    def setup(domain_name, password)
+      runner{ @cli.setup_domain(domain_name, password) }
+    end
+
+    desc "super_admin admin@example.com", "Enable super admin flag of an admin"
+    method_option :disable, :type => :boolean, :aliases => "-d", :desc => "Disable super admin flag"
+    def super_admin(user_name)
+      runner{ @cli.super_admin(user_name, options[:disable]) }
+    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) }
+    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) }
+    end
+
+    desc "add_domain example.com", "Add a domain"
+    def add_domain(domain_name)
+      runner{ @cli.add_domain(domain_name) }
+    end
+
+    desc "delete_domain example.com", "Delete a domain"
+    def 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) }
+    end
+
+    desc "delete_account user@example.com", "Delete an account"
+    def delete_account(address)
+      runner{ @cli.delete_account(address) }
+    end
+
+    desc "add_account user@example.com password", "Add an account"
+    def add_account(address, password)
+      runner{ @cli.add_account(address, password) }
+    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"
+    def add_admin(user_name, password)
+      runner{ @cli.add_admin(user_name, password, options[:super]) }
+    end
+
+    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) }
+    end
+
+    desc "add_alias alias@example.com goto@example.net", "Add an alias"
+    def 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) }
+    end
+
+    desc "version", "Show postfix_admin version"
+    def version
+      require 'postfix_admin/version'
+      say "postfix_admin #{VERSION}"
+    end
+
+    private
+
+    def runner
+      begin
+        yield
+      rescue => e
+        warn e.message
+      end
+    end
+  end
+end

data/lib/postfix_admin/version.rb

@@ -1,3 +1,3 @@
-class PostfixAdmin
-  VERSION = "0.0.2"
+module PostfixAdmin
+  VERSION = "0.1.0"
 end

data/lib/postfix_admin.rb

@@ -1,158 +1,2 @@
 require "postfix_admin/version"
-require 'postfix_admin/models'
-
-require 'date'
-require 'data_mapper'
-
-class PostfixAdmin
-  def initialize(config)
-    DataMapper.setup(:default, config['database'])
-    DataMapper.finalize
-    @config = {}
-    @config[:aliases]   = config['aliases']   || 30
-    @config[:mailboxes] = config['mailboxes'] || 30
-    @config[:maxquota]  = config['maxquota']  || 100
-    @config[:mailbox_quota] = @config[:maxquota] * 1024 * 1000
-  end
-  def add_admin_domain(username, domain)
-    unless admin_exist?(username)
-      raise "Error: #{username} is not resistered as admin."
-    end
-    unless domain_exist?(domain)
-      raise "Error: Invalid domain #{domain}!"
-    end
-    if admin_domain_exist?(username, domain)
-      raise "Error: #{username} is already resistered as admin of #{domain}."
-    end
-
-    domain_admin = DomainAdmin.new
-    domain_admin.attributes = {
-      :username => username,
-      :domain   => domain,
-      :created  => DateTime.now
-    }
-    domain_admin.save
-  end
-  def add_admin(username, password)
-    if admin_exist?(username)
-      raise "Error: #{username} is already resistered as admin."
-    end
-    admin = Admin.new
-    admin.attributes = {
-      :username => username,
-      :password => password,
-      :created  => DateTime.now,
-      :modified => DateTime.now
-    }
-    admin.save
-  end
-  def add_account(address, password)
-    if address !~ /.+\@.+\..+/
-      raise "Error: Invalid mail address! #{address}"
-    end
-    user, domain = address.split(/@/)
-    path = "#{domain}/#{address}/"
-
-    unless domain_exist?(domain)
-      raise "Error: Invalid domain! #{address}"
-    end
-
-    if alias_exist?(address)
-      raise "Error: #{address} is already resistered."
-    end
-    mail_alias = Alias.new
-    mail_alias.attributes = {
-      :address  => address,
-      :goto     => address,
-      :domain   => domain,
-      :created  => DateTime.now,
-      :modified => DateTime.now
-    }
-    mail_alias.save
-
-    mailbox = Mailbox.new
-    mailbox.attributes = {
-      :username => address,
-      :password => password,
-      :name     => '',
-      :maildir  => path,
-      :quota    => @config[:mailbox_quota],
-      :domain   => domain,
-      # :local_part => user,
-      :created  => DateTime.now,
-      :modified => DateTime.now
-    }
-    mailbox.save
-  end
-  def add_alias(address, goto)
-    if alias_exist?(address)
-      goto_text = "#{address},#{goto}"
-      mail_alias = Alias.first(:address => address)
-      mail_alias.update(:goto => goto_text, :modified => DateTime.now)
-    else
-      raise "Error: Invalid mail address! #{address}"
-    end
-  end
-  def add_domain(domain_name)
-    if domain_name !~ /.+\..+/
-      raise "Error: Ivalid domain! #{domain_name}"
-    end
-    if domain_exist?(domain_name)
-      raise "Error: #{domain_name} is already registered!"
-    end
-    domain = Domain.new
-    domain.attributes = {
-      :domain      => domain_name,
-      :description => domain_name,
-      :aliases     => @config[:aliases],
-      :mailboxes   => @config[:mailboxes],
-      :maxquota    => @config[:maxquota],
-      :transport   => "virtual",
-      :backupmx    => 0
-    }
-    domain.save
-  end
-  def delete_domain(domain)
-    unless domain_exist?(domain)
-      raise "Error: #{domain} is not found!"
-    end
-    username = "admin@#{domain}"
-    Admin.all(:username => username).destroy
-    DomainAdmin.all(:username => username).destroy
-    Mailbox.all(:domain => domain).destroy
-    Alias.all(:domain => domain).destroy
-    Domain.all(:domain => domain).destroy
-  end
-  def admin_domain_exist?(username, domain)
-    DomainAdmin.all(:username => username, :domain => domain).count != 0
-  end
-  def admin_exist?(admin)
-    Admin.all(:username => admin).count != 0
-  end
-  def alias_exist?(address)
-    Alias.all(:address => address).count != 0
-  end
-  def domain_exist?(domain)
-    Domain.all(:domain => domain).count != 0
-  end
-  def domains
-    Domain.all(:domain.not => 'ALL', :order => :domain)
-  end
-  def admins
-    Admin.all(:order => 'username')
-  end
-  def mailboxes(domain=nil)
-    if domain
-      Mailbox.all(:domain => domain, :order => :username)
-    else
-      Mailbox.all(:order => :username)
-    end
-  end
-  def admin_domains(username=nil)
-    if username
-      DomainAdmin.all(:username => username, :order => :domain)
-    else
-      DomainAdmin.all(:order => :domain)
-    end
-  end
-end
+require "postfix_admin/base"