zimbra-rest-api 0.1.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3983b077d22f8e4aadacb07f1b9c2d3bcb8ef15d
+  data.tar.gz: 1fedc155082cbb417a38d42fc5f2de94cba22168
+SHA512:
+  metadata.gz: 1008ba7d41a0dce623bea98946e1d10f529eb4b2e28c060e9789118c77480754efa080e41b9bdbfaa3cebbf5e0f8a3a2a440bda41940c6ff80deb908585f36f1
+  data.tar.gz: de154e19295ca91f709b36f198d1165d4e1a2b3369f242b77f0f036a51c90ea79871ba1a617298966e42cf07d6f76a4b1e58a778c81e9937e8b96a486416cf30

data/.gitignore

@@ -0,0 +1,5 @@
+/envs.sh
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Changelog.md

@@ -0,0 +1,46 @@
+### v 0.1.9
+
+#### Get DLs memberships for an Account
+
+```
+ get /accounts/:id/memberships
+```
+
+Returns an Array of DLs Hashes:
+
+```
+[{"id"=>"747972ab-a410-4f17-8d5e-db7be21d75e9",
+  "name"=>"abierta@customer.dev",
+  "via"=>nil},
+ {"id"=>"e92f0d3d-1733-45a2-8e05-967f2d5a0cbe",
+  "name"=>"restringida@customer.dev",
+  "via"=>nil},
+ {"id"=>"8b788848-e670-48b4-a72c-c9097b32a066",
+  "name"=>"restringida@zbox.cl",
+  "via"=>nil}]
+```
+
+
+### v 0.1.8
+
+#### Enable and Disable Archiving for Accounts
+
+```
+ post /accounts/:id/archive/disable
+ post /accounts/:id/archive/enable, { cos_id: cos_id, archive_name: archive_name}
+```
+
+
+### v 0.1.4
+
+#### new endpoint `/distribution_lists/:id/add_members`
+
+```json
+members: { [email1, email2] }
+```
+
+#### new endpoint `/distribution_lists/:id/remove_members`
+
+```json
+members: { [email1, email2] }
+```

data/Dockerfile

@@ -0,0 +1,25 @@
+FROM phusion/passenger-ruby21:0.9.15
+MAINTAINER Patricio Bruna <pbruna@itlinux.cl>
+
+RUN rm -f /etc/service/nginx/down
+RUN rm -f /etc/service/sshd/down
+RUN mkdir -p /home/app/zimbra_pre_auth_router
+RUN mkdir -p /home/app/zimbra_pre_auth_router/tmp
+
+WORKDIR /home/app/zimbra_pre_auth_router
+ADD Gemfile /home/app/zimbra_pre_auth_router/
+ADD Gemfile.lock /home/app/zimbra_pre_auth_router/
+RUN bundle install
+
+ADD config/pbruna-ssh-key.pub /tmp/your_key
+RUN cat /tmp/your_key >> /root/.ssh/authorized_keys && rm -f /tmp/your_key
+RUN apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
+
+# Aquí para que no moleste al cache
+ADD . /home/app/zimbra_pre_auth_router
+ADD config/zimbra_preauth_router-nginx.conf /etc/nginx/sites-enabled/default
+ADD config/nginx-env.conf /etc/nginx/main.d/nginx-env.conf
+
+RUN chown 9999:9999 -R /home/app/zimbra_pre_auth_router
+
+CMD ["/sbin/my_init"]

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zimbra_rest_api.gemspec
+gem 'ruby-zimbra', :github => 'pbruna/ruby-zimbra', :branch => :master
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Patricio Bruna
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+Rake::TestTask.new do |task|
+  task.libs << %w(test lib)
+  task.pattern = 'test/test_*.rb'
+end
+
+task default: :test

data/Readme.md

@@ -0,0 +1,51 @@
+# ZimbraRestApi
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/zimbra_rest_api`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'zimbra_rest_api'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install zimbra_rest_api
+
+## Usage
+
+### Search
+You can search al the objects like:
+
+```
+get '/accounts/', zimbraIsAdminAccount: 'TRUE'
+```
+
+or
+
+```
+ldap_filter = '(|(zimbraMailDeliveryAddress=*@zboxapp.dev)(zimbraMailDeliveryAddress=*@customer1.dev))'
+get '/accounts/', raw_ldap_filter: ldap_filter
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/zimbra_rest_api/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/config.ru

@@ -0,0 +1,22 @@
+require 'bundler'
+Bundler.setup
+require 'zimbra_rest_api'
+
+####### Configurarion Options ############################
+
+ZimbraRestApi.zimbra_soap_url = ENV['zimbra_soap_url']
+ZimbraRestApi.zimbra_admin_user = ENV['zimbra_admin_user']
+ZimbraRestApi.zimbra_admin_password = ENV['zimbra_admin_password']
+#ZimbraRestApi.api_id = "12345678"
+
+####### END CONFIGURATION ############################
+
+###### DONT TOUCH FROM HERE ######################
+
+puts '------------------------------------------------'
+puts 'Starting server with the following configuration'
+puts "SOAP URL: #{ZimbraRestApi.zimbra_soap_url}"
+puts "ADMIN USER: #{ZimbraRestApi.zimbra_admin_user}"
+puts "------------------------------------------------\n"
+
+run ZimbraRestApi::App

data/lib/helpers.rb

@@ -0,0 +1,97 @@
+module ZimbraRestApi
+  module Helpers
+
+    def resource_index(resource, params = {})
+      object = object_factory(resource)
+      begin
+        result = object.all(params)
+        return json({}) if result.nil?
+        set_pagination_headers(result[:search_total], params)
+        json(result[:results])
+      rescue ZimbraRestApi::TO_MANY_RESULTS => e
+        result = { 'errors' => { e.to_s => e.message } }
+        json result
+      end
+    end
+
+    def resource_count(resource, params = {})
+      object = object_factory(resource)
+      params.merge!('max_results' => 0)
+      json object.count(params)
+    end
+
+    def resource_show(resource, id)
+      object = object_factory(resource)
+      result = object.find(id)
+      return json(result) if result
+      status 404
+    end
+
+    def resource_create(resource, params)
+      object = object_factory(resource)
+      begin
+        json object.create(params)
+      rescue Zimbra::HandsoapErrors::SOAPFault => e
+        json({ errors: [ e.message ]})
+      end
+    end
+
+    def resource_update(resource, id, params)
+      object = object_factory(resource)
+      result = object.find(id)
+      return status 404 if result.nil?
+      begin
+        json result.update_attributes(params)
+      rescue Exception => e
+        json({ errors: [ e.message ]})
+      end
+    end
+
+    def resource_delete(resource, id)
+      object = object_factory(resource)
+      result = object.find(id)
+      return status 404 if result.nil?
+      begin
+        result.delete
+        status 200
+      rescue Exception => e
+        json({ errors: [ e.message ]})
+      end
+    end
+
+    def resource_add_grant(resource, id, params)
+      object = object_factory(resource)
+      result = object.find(id)
+      return status 404 if result.nil?
+      begin
+        json result.add_grant(params)
+      rescue Exception => e
+        json({ errors: [ e.message ]})
+      end
+    end
+
+    def resource_revoke_grant(resource, id, params)
+      object = object_factory(resource)
+      result = object.find(id)
+      return status 404 if result.nil?
+      begin
+        json result.revoke_grant(params)
+      rescue Exception => e
+        json({ errors: [ e.message ]})
+      end
+    end
+
+    def set_pagination_headers(total, pagination)
+      headers('X-Total' => total.to_s,
+              'X-Page' => (pagination['page'] || 1).to_s,
+              'X-Per-Page' => (pagination['per_page'] || 10).to_s
+              )
+    end
+
+    def object_factory(resource)
+      "ZimbraRestApi::#{resource.camelize(true)}".constantize
+    end
+
+  end
+
+end

data/lib/models/account.rb

@@ -0,0 +1,58 @@
+# Doc placeholder
+module ZimbraRestApi
+  class Account < ZimbraBase
+
+    def add_alias(alias_name)
+      zmobject.add_alias(alias_name)
+    end
+
+    def delegated_auth_token
+      zmobject.delegated_auth_token
+    end
+
+    def disable_archive
+      zmobject.disable_archive
+    end
+
+    def enable_archive(cos_id = nil, archive_name = nil)
+      zmobject.enable_archive(cos_id, archive_name)
+    end
+
+    def mailbox
+      zmobject.mailbox
+    end
+
+    def memberships
+      results = zmobject.memberships
+      results.map { |r| {id: r.id, name: r.name, via: r.via} }
+    end
+
+    def remove_alias(alias_name)
+      zmobject.remove_alias(alias_name)
+    end
+
+    def self.create(params = {})
+      name = params.delete('name')
+      password = params.delete('password')
+      result = Zimbra::Account.create(name, password, params)
+      new(result)
+    end
+
+    def self.mailbox(account_id)
+      Zimbra::Account.mailbox account_id
+    end
+
+    def set_password(new_password)
+      zmobject.set_password new_password
+    end
+
+    def update_attributes(attributes)
+      if attributes['password']
+        set_password(attributes.delete('password'))
+      end
+      attributes.delete('password')
+      super
+    end
+
+  end
+end

data/lib/models/cos.rb

@@ -0,0 +1,5 @@
+# Doc placeholder
+module ZimbraRestApi
+  class Cos < ZimbraBase
+  end
+end

data/lib/models/distribution_list.rb

@@ -0,0 +1,33 @@
+# Doc placeholder
+module ZimbraRestApi
+  class DistributionList < ZimbraBase
+
+    attr_reader :domain_id
+
+    def initialize(zmobject)
+      super
+      @domain_id = name.split(/@/)[1]
+    end
+
+    def add_members(members)
+      zmobject.add_members(members)
+    end
+
+    def remove_members(members)
+      zmobject.remove_members(members)
+    end
+
+    def modify_members(members)
+      zmobject.modify_members members
+    end
+
+    def update_attributes(attributes)
+      if attributes['members']
+        modify_members(attributes.delete('members'))
+      end
+      attributes.delete('members')
+      super
+    end
+
+  end
+end

data/lib/models/domain.rb

@@ -0,0 +1,19 @@
+# Doc placeholder
+module ZimbraRestApi
+  class Domain < ZimbraBase
+
+    def self.count_accounts(domain_id)
+      Zimbra::Domain.count_accounts domain_id
+    end
+
+    def count_accounts
+      zmobject.count_accounts
+    end
+
+    def set_max_accounts(total = 0, cos_quota = [])
+      result = zmobject.set_max_accounts total, cos_quota
+      Domain.new result
+    end
+
+  end
+end

data/lib/models/zimbra_base.rb

@@ -0,0 +1,33 @@
+module ZimbraRestApi
+  class ZimbraBase
+    include ZimbraRestApi::ZimbraObject
+
+    attr_accessor :zmobject
+
+    def initialize(zmobject)
+      @zmobject = zmobject
+      @zmobject.acls # Force loading
+      instance_variables = get_instance_values(zmobject)
+      set_instance_variables(instance_variables)
+    end
+
+    private
+
+    def get_instance_values(object)
+      return nil if object.nil?
+      hash = {}
+      object.instance_variables.each do |v|
+        hash[v] = object.instance_variable_get(v)
+      end
+      hash
+    end
+
+    def set_instance_variables(instance_variables)
+      instance_variables.each do |name, value|
+        instance_variable_set(name, value)
+        self.class.send(:attr_accessor, name.to_s.gsub(/@/, ''))
+      end
+    end
+
+  end
+end

data/lib/zimbra_rest_api.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'uri'
+require 'uuid'
+require 'zimbra'
+require 'pp'
+require_relative 'helpers'
+require_relative 'zimbra_rest_api/zimbra_object'
+require_relative 'zimbra_rest_api/utils'
+require_relative 'zimbra_rest_api/errors'
+require_relative 'models/zimbra_base'
+require_relative 'models/domain'
+require_relative 'models/account'
+require_relative 'models/distribution_list'
+require_relative 'models/cos'
+
+# Doc placeholder
+module ZimbraRestApi
+  autoload :App, 'zimbra_rest_api/app'
+
+  class << self
+    attr_accessor :zimbra_admin_user, :zimbra_admin_password
+    attr_accessor :api_id
+    attr_writer :zimbra_max_results
+    attr_reader :zimbra_soap_url
+
+    def authenticate!
+      Zimbra.admin_api_url = zimbra_soap_url
+      Zimbra.login(zimbra_admin_user, zimbra_admin_password)
+    end
+
+    def zimbra_max_results
+      @zimbra_max_results ||= 200
+    end
+
+    def zimbra_soap_url=(url)
+      uri = URI.parse(url)
+      fail URI::InvalidURIError unless uri.is_a?(URI::HTTP)
+      @zimbra_soap_url = url
+    end
+
+  end
+end

data/lib/zimbra_rest_api/app.rb

@@ -0,0 +1,207 @@
+require 'sinatra/base'
+require 'sinatra/cookies'
+require 'sinatra/json'
+require 'logger'
+
+class Sinatra::Base
+  set :show_exceptions => false
+
+  error { |err|
+    Rack::Response.new(
+      [{'error' => err.message}.to_json],
+      500,
+      {'Content-type' => 'application/json'}
+    ).finish
+  }
+end
+
+# Doc placeholder
+module ZimbraRestApi
+  class App < Sinatra::Base
+    helpers Sinatra::Cookies, ZimbraRestApi::Helpers
+
+    RESOURCES = %w(domain account distribution_list cos)
+
+    before do
+      if ZimbraRestApi.api_id
+        error 401 unless env['HTTP_X_API_TOKEN'] == ZimbraRestApi.api_id
+      end
+      ZimbraRestApi.authenticate!
+    end
+
+    configure :production, :development do
+      enable :logging
+      enable :session
+    end
+
+    RESOURCES.each do |resource|
+      # Index route
+      get "/#{resource.plural}/?" do
+        resource_index(resource, params)
+      end
+
+      # Count route
+      get "/#{resource.plural}/count" do
+        resource_count(resource, request.params)
+      end
+
+      # Show route
+      get "/#{resource.plural}/:id/?" do
+        resource_show(resource, params['id'])
+      end
+
+      # Create route
+      post "/#{resource.plural}/?" do
+        resource_create(resource, params)
+      end
+
+      # Update route
+      put "/#{resource.plural}/:id/?" do
+        resource_update(resource, params[:id], request.params)
+      end
+
+      # Delete route
+      delete "/#{resource.plural}/:id/?" do
+        resource_delete(resource, params[:id])
+      end
+
+      # Add grants
+      post "/#{resource.plural}/:id/grants/add/?" do
+        resource_add_grant(resource, params[:id], request.params)
+      end
+
+      # Revoke grants
+      post "/#{resource.plural}/:id/grants/revoke/?" do
+        resource_revoke_grant(resource, params[:id], request.params)
+      end
+
+    end
+
+    # Domains nested routes
+
+    # Domain count_accounts
+    get '/domains/:id/count_accounts' do
+      # We need the id, so we lookup the domain if we do not get an UUID
+      if UUID.validate(params['id'])
+        json Domain.count_accounts(params['id'])
+      else
+        domain = Domain.find(params['id'])
+        json domain.count_accounts
+      end
+    end
+
+    # Domain accounts
+    get '/domains/:id/accounts' do
+      # Only lookup domain if id is an UUID
+      domain = params['id']
+      domain = Domain.find(params['id']) if UUID.validate(params['id'])
+      query = request.params.merge(domain: domain.to_s)
+      resource_index('account', query)
+    end
+
+    # Domain Distribution Lists
+    get '/domains/:id/distribution_lists' do
+      # Only lookup domain if id is an UUID
+      domain = params['id']
+      domain = Domain.find(params['id']) if UUID.validate(params['id'])
+      query = request.params.merge(domain: domain.to_s)
+      resource_index('distribution_list', query)
+    end
+
+    # Domain Add Accounts Quota
+    post '/domains/:id/accounts_quota' do
+      domain = Domain.find(params['id'])
+      max_accounts = request.params['total']
+      quota_by_cos = request.params['cos']
+      json domain.set_max_accounts(max_accounts, quota_by_cos)
+    end
+
+    # Accounts custom routes
+    # Account mailbox info
+    get '/accounts/:id/mailbox' do
+      # We need the id, so we lookup the account if we do not get an UUID
+      if UUID.validate(params['id'])
+        json Account.mailbox(params['id'])
+      else
+        account = Account.find(params['id'])
+        json account.mailbox
+      end
+    end
+
+    post '/accounts/:id/add_alias' do
+      account = Account.find(params['id'])
+      alias_name = request.params['alias_name']
+      if account.add_alias(alias_name)
+        json alias_name: alias_name
+      else
+        json errors: ["Alias not added for #{account.name}"]
+      end
+    end
+
+    post '/accounts/:id/remove_alias' do
+      account = Account.find(params['id'])
+      alias_name = request.params['alias_name']
+      if account.remove_alias(alias_name)
+        json alias_name: alias_name
+      else
+        json errors: ["Alias no removed for #{account.name}"]
+      end
+    end
+
+    get '/accounts/:id/delegated_token' do
+      account = Account.find(params['id'])
+      token = account.delegated_auth_token
+      json delegated_token: token
+    end
+
+    # Enable account archive
+    # params => cos_id, archive_name
+    post "/accounts/:id/archive/enable" do
+      account = Account.find(params['id'])
+      cos_id = request.params['cos_id']
+      archive_name = request.params['archive_name']
+      result = account.enable_archive(cos_id, archive_name)
+      json result: result
+    end
+
+    # Disable account archive
+    post "/accounts/:id/archive/disable" do
+      account = Account.find(params['id'])
+      result = account.disable_archive
+      json result: result
+    end
+
+    # Account DLs memberships
+    get '/accounts/:id/memberships' do
+      account = Account.find(params['id'])
+      memberships = account.memberships
+      json memberships
+    end
+
+    # DistributionList
+
+    # add_members
+    post '/distribution_lists/:id/add_members' do
+      dl = DistributionList.find params['id']
+      members = request.params['members']
+      begin
+        json DistributionList.new(dl.add_members members)
+      rescue Exception => e
+        json({ errors: [ e.message ]})
+      end
+    end
+
+    # add_members
+    post '/distribution_lists/:id/remove_members' do
+      dl = DistributionList.find params['id']
+      members = request.params['members']
+      begin
+        json DistributionList.new(dl.remove_members members)
+      rescue Exception => e
+        json({ errors: [ e.message ]})
+      end
+    end
+
+    run! if app_file == $PROGRAM_NAME
+  end
+end

data/lib/zimbra_rest_api/errors.rb

@@ -0,0 +1,5 @@
+module ZimbraRestApi
+
+  class TO_MANY_RESULTS < StandardError; end
+
+end

data/lib/zimbra_rest_api/utils.rb

@@ -0,0 +1,20 @@
+class String
+
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      self[0] + camelize(self)[1..-1]
+    end
+  end
+
+  def constantize
+    Object.const_get self
+  end
+
+  def plural
+    return self if self.downcase == 'cos'
+    self.to_s + 's'
+  end
+
+end

data/lib/zimbra_rest_api/version.rb

@@ -0,0 +1,3 @@
+module ZimbraRestApi
+  VERSION = '0.1.9'
+end

data/lib/zimbra_rest_api/zimbra_object.rb

@@ -0,0 +1,175 @@
+module ZimbraRestApi
+
+  # Class placeholder
+  module ZimbraObject
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.extend ClassMethods
+    end
+
+    module InstanceMethods
+      def to_json(arg = nil)
+        hash = {}
+        self.instance_variables.each do |var|
+          name = var.to_s.gsub(/@/, '')
+          hash[name] = self.instance_variable_get var
+        end
+        hash.to_json
+      end
+
+      def from_json! string
+        JSON.load(string).each do |var, val|
+            self.instance_variable_set var, val
+        end
+      end
+
+      def update_attributes(attributes)
+        fail ArgumentError.new('Hash expected') unless attributes.is_a?Hash
+        result = zmobject.modify(attributes)
+        self.class.new(result) if result
+      end
+
+      def delete
+        zmobject.delete
+      end
+
+      def acl_factory(attrs = {})
+        fail ArgumentError.new('Hash expected') unless attrs.is_a?Hash
+        return if attrs.empty?
+        attrs['grantee_class'] = Zimbra::ACL::TARGET_MAPPINGS[attrs['grantee_class']]
+        Zimbra::ACL.new(grantee_name: attrs['grantee_name'],
+                              grantee_class: attrs['grantee_class'],
+                              name: attrs['name']
+                              )
+      end
+
+      def add_grant(grant)
+        acl = acl_factory(grant)
+        if Zimbra::Directory::add_grant(self.zmobject, acl)
+          self.class.find(self.id)
+        else
+          fail ZimbraRestApi::NotFound, "ZimbraRestApi::NotFound Grant #{acl.grantee_name}"
+        end
+      end
+
+      def revoke_grant(grant)
+        acl = acl_factory(grant)
+        if Zimbra::Directory::revoke_grant(self.zmobject, acl)
+          return self.class.find(self.id)
+        else
+          fail ZimbraRestApi::NotFound, "ZimbraRestApi::NotFound Grant #{acl.grantee_name}"
+        end
+      end
+
+    end
+
+    # Doc placeholder
+    module ClassMethods
+
+      def all(query = {}, object = nil)
+        zimbra_object = get_zimbra_object(object)
+        search_result = search(zimbra_object, query)
+        return nil if search_result.nil?
+        raw_els = search_result[:results]
+        search_result[:results] = raw_els.nil? ? [] : raw_els.map do |o|
+          new(o)
+        end
+        search_result
+      end
+
+      def count(query = {}, object = nil)
+        query ||= {}
+        query[:count_only] = true
+        query['per_page'] = 0
+        zimbra_object = get_zimbra_object(object)
+        result = search(zimbra_object, query)
+        !result.nil? ? result : { count: 0 }
+      end
+
+      def create(params = {}, object = nil)
+        zimbra_object = get_zimbra_object(object)
+        name = params.delete('name')
+        result = zimbra_object.create(name, params)
+        new(result)
+      end
+
+      def find(query, object = nil)
+        zimbra_object = get_zimbra_object(object)
+        if UUID.validate(query)
+          result = zimbra_object.find_by_id(query)
+        else
+          result = zimbra_object.find_by_name(query)
+        end
+        result.nil? ? nil : new(result)
+      end
+
+      def get_zimbra_object(object)
+        object ||= self.is_a?(Class) ? name : self.class.name
+        object.gsub!(/ZimbraRestApi::/, '')
+        "Zimbra::#{object.camelize}".constantize
+      end
+
+      def search(object, query)
+        zimbra_type = object.name.split(/::/).last.downcase
+        search_hash = build_search_hash(query)
+        search_hash.merge!(type: zimbra_type)
+        query = search_hash.delete(:query)
+        begin
+          Zimbra::Directory.search(query, search_hash)
+        rescue Zimbra::HandsoapErrors::SOAPFault => e
+          msg = 'number of results exceeded the limit: too many search results returned'
+          raise ZimbraRestApi::TO_MANY_RESULTS if e.message == msg
+        end
+      end
+
+      def build_search_hash(query = {})
+        query_dup = query.clone
+        sort_options_hash = get_sort_ops(query_dup)
+        count_only = query_dup.delete('count_only') || query_dup.delete(:count_only)
+        query_hash = {
+          domain: query_dup.delete('domain') || query_dup.delete(:domain),
+          query: hash_to_ldap(query_dup)
+        }
+        query_hash.merge(sort_options_hash).merge(count_only: count_only)
+      end
+
+      def get_sort_ops(query)
+        page = query.delete('page') || 0
+        limit = query.delete('per_page') || 0
+        max_results = query.delete('max_results') || ZimbraRestApi.zimbra_max_results
+        attrs = query.delete('attrs') || nil
+        offset = page.to_i <= 1 ? 0 : ((page.to_i - 1) * limit.to_i)
+        { limit: limit.to_i,
+          offset: offset.to_i, attrs: attrs, max_results: max_results }
+      end
+
+      def hash_to_ldap(query = {})
+        raw_filter = query.delete('raw_ldap_filter').to_s
+        if query.delete('inverse_filter')
+          result = query.map { |k, v| "(!(#{k}=#{v}))" }.join('')
+        else
+          result = query.map { |k, v| "(#{k}=#{v})" }.join('')
+        end
+        raw_filter << "(&#{result})"
+        raw_filter
+      end
+
+      def zimbra_attrs_to_load=(array)
+        klass_name = self.name.split(/::/)[1]
+        klass = "Zimbra::#{klass_name}".constantize
+        fail(ArgumentError, 'Must be an array') unless array.is_a?Array
+        klass.zimbra_attrs_to_load = array
+      end
+
+      def zimbra_attrs_to_load
+        klass_name = self.name.split(/::/)[1]
+        klass = "Zimbra::#{klass_name}".constantize
+        return [] if klass.zimbra_attrs_to_load.nil?
+        klass.zimbra_attrs_to_load
+      end
+    end
+  end
+
+  class NotFound < StandardError; end
+
+end

data/zimbra_rest_api.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'zimbra_rest_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "zimbra-rest-api"
+  spec.version       = ZimbraRestApi::VERSION
+  spec.authors       = ["Patricio Bruna"]
+  spec.license       = "MIT"
+  spec.email         = ["pbruna@itlinux.cl"]
+
+  spec.summary       = 'Zimbra REST API Proxy to Zimbra SOAP API'
+  spec.description   = 'Zimbra REST API Proxy to Zimbra SOAP API.'
+  spec.homepage      = 'https://github.com/pbruna/zimbra-rest-api'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'sinatra', '~> 1.4'
+  spec.add_dependency 'uuid', '~> 2.3'
+  spec.add_dependency 'httpclient', '~> 2.6'
+  spec.add_dependency 'sinatra-contrib', '~> 1.4'
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency 'minitest-reporters', '~> 1.0', '>= 1.0.19'
+  spec.add_development_dependency 'pry', '~> 0.10'
+end

metadata

@@ -0,0 +1,185 @@
+--- !ruby/object:Gem::Specification
+name: zimbra-rest-api
+version: !ruby/object:Gem::Version
+  version: 0.1.9
+platform: ruby
+authors:
+- Patricio Bruna
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: uuid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.19
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.19
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Zimbra REST API Proxy to Zimbra SOAP API.
+email:
+- pbruna@itlinux.cl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Changelog.md
+- Dockerfile
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- Rakefile
+- Readme.md
+- config.ru
+- lib/helpers.rb
+- lib/models/account.rb
+- lib/models/cos.rb
+- lib/models/distribution_list.rb
+- lib/models/domain.rb
+- lib/models/zimbra_base.rb
+- lib/zimbra_rest_api.rb
+- lib/zimbra_rest_api/app.rb
+- lib/zimbra_rest_api/errors.rb
+- lib/zimbra_rest_api/utils.rb
+- lib/zimbra_rest_api/version.rb
+- lib/zimbra_rest_api/zimbra_object.rb
+- zimbra_rest_api.gemspec
+homepage: https://github.com/pbruna/zimbra-rest-api
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Zimbra REST API Proxy to Zimbra SOAP API
+test_files: []
+has_rdoc: