mailroute 0.0.1

data/lib/mailroute/extensions/object.rb

@@ -0,0 +1,3 @@
+class Object
+  alias_method :public_send, :send
+end if RUBY_VERSION =~ /^1\.8/

data/lib/mailroute/extensions/relation.rb

@@ -0,0 +1,59 @@
+require 'active_support/core_ext'
+
+class Mailroute::Relation
+  delegate :inspect, :each, :count, :&, :to_ary, :all?, :empty?, :to => :to_a
+  include Enumerable
+
+  attr_reader :search_options
+
+  def initialize(klass, search_options = {})
+    @klass = klass
+    @search_options = search_options
+  end
+
+  def to_a
+    @records ||= @klass.all(search_options)
+  end
+
+  def limit(n)
+    new_relation(:params => { :limit => n })
+  end
+
+  def offset(n)
+    new_relation(:params => { :offset => n })
+  end
+
+  def filter(options)
+    new_relation(:params => options)
+  end
+
+  def order_by(attribute)
+    new_relation(:params => { :order_by => attribute })
+  end
+
+  def search(term)
+    new_relation(:params => { :q => term })
+  end
+
+  def ==(other)
+    case other
+    when Relation
+      search_options == other.search_options
+    when Array
+      to_a == other
+    else
+      false
+    end
+  end
+
+  def total_count
+    meta = to_a.instance_variable_get(:@_meta)
+    meta && meta['total_count']
+  end
+
+  private
+
+  def new_relation(options_update)
+    Mailroute::Relation.new(@klass, search_options.deep_merge(options_update))
+  end
+end

data/lib/mailroute/models/admin.rb

@@ -0,0 +1,21 @@
+module Mailroute
+  class Admin < Base
+    self.collection_name = 'admins'
+
+    def self.collection_path(prefix_options = {}, query_options = nil)
+      scope = prefix_options.delete(:scope) || (query_options && query_options.delete(:scope))
+      raise 'Scope is missing' unless scope
+      check_prefix_options(prefix_options)
+      prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+      "#{prefix(prefix_options)}admins/#{scope[:name]}/#{scope[:id]}/#{query_string(query_options)}"
+    end
+
+    def self.element_path(id, prefix_options = {}, query_options = nil)
+      scope = prefix_options.delete(:scope) || (query_options && query_options.delete(:scope))
+      raise 'Scope is missing' unless scope
+      check_prefix_options(prefix_options)
+      prefix_options, query_options = split_options(prefix_options) if query_options.nil?
+      "#{prefix(prefix_options)}admins/#{scope[:name]}/#{scope[:id]}/admin/#{URI.parser.escape id.to_s}/#{query_string(query_options)}"
+    end
+  end
+end

data/lib/mailroute/models/base.rb

@@ -0,0 +1,193 @@
+module Mailroute
+  class Base < ActiveResource::Base
+    include ActiveResource::Extensions::UrlsWithoutJsonExtension
+
+    class << self
+      def meta
+        @meta ||= MetaInformation.new(self)
+      end
+
+      def headers
+        if defined?(@headers)
+          @headers
+        elsif superclass.respond_to? :headers
+          @headers ||= superclass.headers
+        else
+          @headers ||= {}
+        end
+      end
+
+      delegate :limit, :offset, :filter, :order_by, :search, :to => :list
+
+      def list(options = {})
+        Relation.new(self)
+      end
+
+      def bulk_create(*attribute_array)
+        attribute_array.map do |attributes|
+          create(attributes)
+        end
+      end
+
+      alias_method :get, :find
+
+      def delete(*array)
+        array.map do |r|
+          if r.is_a? Mailroute::Base
+            r.destroy
+          else
+            connection.delete(element_path(r, {}), headers)
+          end
+        end
+      end
+
+      alias_method :instantiate_collection_without_meta, :instantiate_collection
+      def instantiate_collection(collection, prefix_options = {})
+        array = instantiate_collection_without_meta(collection, prefix_options)
+        array.instance_variable_set(:@_meta, collection.instance_variable_get(:@_meta))
+        array
+      end
+
+      def total_count
+        limit(1).total_count
+      end
+    end
+
+    def to_json(options = {})
+      super(options.merge(:root => false))
+    end
+
+    alias_method :delete, :destroy
+
+    def self.has_one(model, options = {})
+      relation = meta.add_has_one(model, options)
+
+      self.send(:define_method, model.to_s) do
+        foreign_class = relation.foreign_class
+
+        @_associations[model] ||= foreign_class.get(extract_id(super())).tap do |obj|
+          obj.send("#{relation.inverse}=",  self)
+        end if super()
+      end
+
+      self.send(:define_method, "#{model}=") do |v|
+        if v.is_a? Mailroute::Base
+          @_associations[model] = v
+
+          super(v.resource_uri)
+        else
+          super(v)
+        end
+      end
+    end
+
+    def load(attributes, remove_root = false)
+      new_attributes = {}
+      attributes.each do |k, v|
+        new_attributes[k] = if v.is_a? Mailroute::Base
+                              v.resource_uri
+                            else
+                              v
+                            end
+      end
+      super(new_attributes, remove_root)
+    end
+
+    def self.has_many(model, options = {})
+      relation = meta.add_has_many(model, options)
+
+      self.send(:define_method, model.to_s) do
+        foreign_class = relation.foreign_class
+
+        @_associations[model] ||= foreign_class.filter(relation.inverse.to_sym => id).to_a
+      end
+
+      self.send(:define_method, "create_#{ActiveSupport::Inflector.singularize(model.to_s)}") do |options|
+        foreign_class = relation.foreign_class
+
+        @_associations[model] = nil
+        if relation.pk && options.is_a?(String) && options !~ /^\/api\/v1/
+          relation.foreign_class.create(relation.inverse.to_s => id, relation.pk => options)
+        else
+          relation.foreign_class.create(options.merge(relation.inverse.to_s => id))
+        end
+      end
+    end
+
+    def self.has_admins(options = {})
+      relation = meta.add_has_admins(options)
+
+      self.send(:define_method, :admins) do
+        foreign_class = relation.foreign_class
+
+        @_associations[:admins] ||= foreign_class.all(:params => {:scope => { :name => relation.inverse.to_s, :id => id}}).to_a
+      end
+
+      self.send(:define_method, :create_admin) do |email, send_welcome|
+        send_welcome = !!send_welcome
+        foreign_class = relation.foreign_class
+
+        @_associations[:admin] = nil
+        admin = relation.foreign_class.new(:email => email, :send_welcome => send_welcome)
+        admin.prefix_options[:scope] = { :name => relation.inverse.to_s, :id => id }
+        admin.save!
+        admin
+      end
+
+      self.send(:define_method, :delete_admin) do |email|
+        foreign_class = relation.foreign_class
+
+        @_associations[:admin] = nil
+        admin = relation.foreign_class.all(:params => {:email => email, :scope => { :name => relation.inverse.to_s, :id => id}}).first
+
+        if admin
+          admin.prefix_options[:scope] = { :name => relation.inverse.to_s, :id => id }
+          admin.destroy
+        end
+      end
+    end
+
+    def reload
+      @_associations = {}.with_indifferent_access
+      super
+    end
+
+    def initialize(attributes = {}, persisted = false)
+      @_associations = {}.with_indifferent_access
+      new_attributes = attributes.dup
+      attributes.each do |k, v|
+        next unless self.class.meta.associations.has_key?(k.to_sym)
+        relation = self.class.meta.associations[k.to_sym]
+
+        case v
+        when Integer
+          new_attributes[k] = relation.foreign_class.element_path(v)
+        when Mailroute::Base
+          @_associations[k] = v
+          new_attributes[k] = v.element_path
+        when String
+          if relation.pk && v !~ /^\/api\/v1/
+            all = relation.foreign_class.filter(relation.pk => v).limit(2).to_a
+            case all.size
+            when 0 then raise 'there is no such records'
+            when 2 then raise 'there are too many records'
+            end
+            fst = all.first
+            @_associations[k] = fst
+            new_attributes[k] = fst.element_path
+          else
+            new_attributes[k] = v
+          end
+        end
+      end
+
+      super(new_attributes, persisted)
+    end
+
+    private
+
+    def extract_id(uri)
+      uri.match(/(\/|^)(\d+)\/?$/)[2].to_i
+    end
+  end
+end

data/lib/mailroute/models/branding_info.rb

@@ -0,0 +1,5 @@
+module Mailroute
+  class BrandingInfo < Base
+    self.collection_name = 'brandinginfo'
+  end
+end

data/lib/mailroute/models/customer.rb

@@ -0,0 +1,10 @@
+module Mailroute
+  class Customer < Base
+    self.collection_name = 'customer'
+    has_one :reseller, :pk => 'name'
+    has_one :branding_info
+    has_many :domains
+    has_many :contacts, :class => CustomerContact
+    has_admins :class => Admin
+  end
+end

data/lib/mailroute/models/customer_contact.rb

@@ -0,0 +1,6 @@
+module Mailroute
+  class CustomerContact < Base
+    self.collection_name = 'contact_customer'
+    has_one :customer
+  end
+end

data/lib/mailroute/models/domain.rb

@@ -0,0 +1,56 @@
+module Mailroute
+  class Domain < Base
+    self.collection_name = 'domain'
+    has_one :customer
+    has_many :domain_aliases
+    has_many :email_accounts
+    has_many :mail_servers
+    has_many :outbound_servers, :pk => :server
+    has_many :contacts, :class => DomainContact
+    has_many :wblist, :class => WBList
+    has_one :policy, :class => PolicyDomain
+    has_one :notification_task, :class => NotificationDomainTask
+
+    def blacklist
+      WBList.filter(:domain => id, :wb => 'b').map(&:email)
+    end
+
+    def whitelist
+      WBList.filter(:domain => id, :wb => 'w').map(&:email)
+    end
+
+    def add_to_blacklist(address)
+      create_wblist(:wb => 'b', :email => address)
+    end
+
+    def add_to_whitelist(address)
+      create_wblist(:wb => 'w', :email => address)
+    end
+
+    def move_to_customer(another_customer)
+      self.customer = another_customer
+      self.save!
+    end
+
+    def bulk_create_email_account(localparts)
+      connection.post(element_path + 'email_accounts/mass_add/', localparts.to_json, self.class.headers).tap do |response|
+        ap response
+      end
+    end
+
+    class << self
+      alias_method :get_by_id, :get
+
+      def get(id_or_name)
+        case id_or_name
+        when String
+          filter(:name => id_or_name).first
+        when Integer
+          get_by_id(id_or_name)
+        else
+          raise 'Unknown argument type'
+        end
+      end
+    end
+  end
+end

data/lib/mailroute/models/domain_alias.rb

@@ -0,0 +1,6 @@
+module Mailroute
+  class DomainAlias < Base
+    self.collection_name = 'domain_alias'
+    has_one :domain
+  end
+end

data/lib/mailroute/models/domain_contact.rb

@@ -0,0 +1,6 @@
+module Mailroute
+  class DomainContact < Base
+    self.collection_name = 'contact_domain'
+    has_one :domain
+  end
+end

data/lib/mailroute/models/email_account.rb

@@ -0,0 +1,53 @@
+module Mailroute
+  class EmailAccount < Base
+    self.collection_name = 'email_account'
+    has_one :domain
+    has_one :policy, :class => PolicyUser
+    has_one :notification_task, :class => NotificationAccountTask
+    has_one :contact, :class => EmailAccountContact
+    has_many :wblist, :class => WBList
+
+    def blacklist
+      WBList.filter(:email_account => id, :wb => 'b').map(&:email)
+    end
+
+    def whitelist
+      WBList.filter(:email_account => id, :wb => 'w').map(&:email)
+    end
+
+    def add_to_blacklist(address)
+      create_wblist(:wb => 'b', :email => address)
+    end
+
+    def add_to_whitelist(address)
+      create_wblist(:wb => 'w', :email => address)
+    end
+
+    def set_password(new_password)
+      self.password = new_password
+      save!
+      self
+    end
+
+    class << self
+      alias_method :get_by_id, :get
+      def get(*args)
+        if args.size == 1
+          get_by_id(*args)
+        else
+          localpart, domain = *args
+          case domain
+          when Domain
+            get(localpart, domain.id)
+          when String
+            get(localpart, Domain.get(domain))
+          when Integer
+            EmailAccount.filter(:domain => domain, :localpart => localpart).first or raise ActiveResource::ResourceNotFound
+          else
+            raise 'Unknown argument type'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mailroute/models/email_account_contact.rb

@@ -0,0 +1,6 @@
+module Mailroute
+  class EmailAccountContact < Base
+    self.collection_name = 'contact_email_account'
+    has_one :email_account
+  end
+end

data/lib/mailroute/models/mail_server.rb

@@ -0,0 +1,6 @@
+module Mailroute
+  class MailServer < Base
+    self.collection_name = 'mail_server'
+    has_one :domain
+  end
+end