dhis2 0.1.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 77af2d4ee9db850966b8fe67375be8554acfbe72
-  data.tar.gz: 79a9fccf546c3e1b5d94e85ca17718dcfb520c44
+  metadata.gz: ed649a064de87ceea944479aa82f20e239e912ee
+  data.tar.gz: 862e2be603b90d7da556faae38ba8df02ee51759
 SHA512:
-  metadata.gz: 91d423b15b3adcd7371f281b908170ac12a902a408957e18c3b78be32973a3435e1d2479d1c34bd1f0273aea785ece0b368ce183d37291f70529c109b5760065
-  data.tar.gz: 5dafa945e708eea647ec1b097f10c32b6b83d886bab1f33b9f1741ec0f8719490a81f291e0807fbdbfebd066caad95361c1890ba89b1b534efd5ce87471af636
+  metadata.gz: 5ccb72a75795cd3c0e9d1b863ea25c93181410d09cf03dacafebe19b25c84a99defc1da3aaee01236b61f530f9381b4c177a2cb2c9ae608d7d046cf9cb0c9f39
+  data.tar.gz: 82a608fd72682b034e53b4df5107474ea4b89b14bc93968829398b55499f2abfa05afd7bedded231be603bff9697c33195087ee63fe49eb2694fd48c79224bc5

data/README.md

@@ -1,5 +1,7 @@
 # Dhis2
 
+<a href="https://codeclimate.com/github/BLSQ/dhis2"><img src="https://codeclimate.com/github/BLSQ/dhis2/badges/gpa.svg" /></a>
+
 Basic DHIS2 API client for Ruby.
 
 ## Installation
@@ -7,7 +9,8 @@ Basic DHIS2 API client for Ruby.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'dhis2', :github => 'BLSQ/dhis2' # not published yet, so get it from github
+gem 'dhis2' # get it from RubyGems
+gem 'dhis2', github: 'BLSQ/dhis2' # OR get the bleeding edge version from github
 ```
 
 And then execute:
@@ -24,21 +27,47 @@ Or install it yourself as:
 
 The functionalities are available as a module. First thing you need to do is to connect to the instance:
 
-    Dhis2.connect(url: "https://play.dhis2.org/demo", user: "admin", password: "district")
+* Global configuration (to call a single Dhis2 instance):
+
+  ```ruby 
+  Dhis2.configure do |config|
+    config.url      = "https://play.dhis2.org/demo"
+    config.user     = "admin"
+    config.password = "district"
+  end
+  Dhis2.client.data_elements.list # => Array[<DataElement>,..]
+
+  # Or alternatively
+  Dhis2.configure do |config|
+    config.url = "https://admin:district@play.dhis2.org/demo"
+  end
+  Dhis2.client.data_elements.list # => Array[<DataElement>,..]
+  ```
+
+* Local configuration: (in case you need to access different Dhis2 instances inside a single project):
+  
+  ```ruby 
+  client = Dhis2::Client.new(url: "https://play.dhis2.org/demo", user: "admin", password: "district")
+  client.data_elements.list # => Array[<DataElement>,..]
 
-### Search for elements
+  # Or alternatively
+  client = Dhis2::Client.new("https://admin:district@play.dhis2.org/demo")
+  client.data_elements.list # => Array[<DataElement>,..]
+  ```
 
-All subsequent calls can be done on the object themselves and are going to use the provided url and credentials
+### Search for meta elements
 
-    org_unit_levels = Dhis2::OrganisationUnitLevel.list
+All subsequent calls can be done on the objects themselves and are going to use the provided url and credentials
+
+    org_unit_levels = Dhis2.client.organisation_unit_levels.list
 
 The various methods are taking an optional hash parameter to be used for ´filter´ and ´fields´ values:
 
-    org_units = Dhis2::OrganisationUnit.list(filter: "level:eq:2", fields: %w(id level displayName parent))
+    org_units = Dhis2.client.organisation_units.list(filter: "level:eq:2", fields: %w(id level displayName parent))
 
 If you want all fields, simply specify `:all`
 
-    org_units = Dhis2::OrganisationUnit.list(filter: "level:eq:2", fields: :all)
+    org_units = Dhis2.client.organisation_units.list(filter: "level:eq:2", fields: :all)
 
 Notes that any field found in the resulting JSON will be accessible from the object.
 
@@ -46,7 +75,7 @@ Notes that any field found in the resulting JSON will be accessible from the obj
 
 Following the DHIS2 API, all calls are paginated - you can access the page info using the `pager` property on the returned list:
 
-    org_units = Dhis2::OrganisationUnit.list(filter: "level:eq:2", fields: %w(id level displayName parent))
+    org_units = Dhis2.client.organisation_units.list(filter: "level:eq:2", fields: %w(id level displayName parent))
     org_units.pager.page       # current page
     org_units.pager.page_count # number of pages 
     org_units.pager.total      # number of records
@@ -55,37 +84,60 @@ Following the DHIS2 API, all calls are paginated - you can access the page info
 
 You can also retreive a single element using its id with `find`(in this case, all fields are returned by default):
 
-    ou = Dhis2.Dhis2::OrganisationUnit.find(id)
+    ou = Dhis2.client.organisation_units.find(id)
+
+`find` also accepts multiple ids - query will not be paginated and will return all fields for the given objects:
+
+    ous = Dhis2.client.organisation_units.find([id1, id2, id3])
 
 If you have an equality condition or set of equality conditions that should return a single element, you can use `find_by` instead of the longer list option:
 
     # Instead of this:
-    data_element = Dhis2::DataElement.list(filter: "code:eq:C27", fields: :all).first
+    data_element = Dhis2.client.data_elements.list(filter: "code:eq:C27", fields: :all).first
 
     # Just do:
-    data_element = Dhis2::DataElement.find_by(code: "C27")
+    data_element = Dhis2.client.data_elements.find_by(code: "C27")
+
+### Values
+
+You can retreive data values this way:
+
+    ds                = Dhis2.client.data_sets.find_by(name: "Child Health")
+    organisation_unit = Dhis2.client.organisation_units.find_by(name: "Baoma")
+    period            = "201512"
+    value_sets        = Dhis2.client.data_value_sets.list(
+      data_sets: [ds.id], 
+      organisation_unit: organisation_unit.id, periods: [period]
+    )
 
 ## Supported features
 
-The API is currently limited to **read** actions on the following elements:
+The API is currently limited to **read** actions on the following elements/classes:
 
-* Organisation Units
-* Organisation Units Levels
-* Data Elements
-* Data Sets
+* `OrganisationUnit`
+* `OrganisationUnitLevels`
+* `DataElement`
+* `DataSet`
+* `CategoryCombo`
 
-A very basic **write** use case exists for Data Elements and Data Sets:
+A very basic **write** use case exists for `DataElement` and `DataSet`:
 
     elements = [
-          { name: "TesTesT1", short_name: "TTT1" },
-          { name: "TesTesT2", short_name: "TTT2" }
-        ]
-    status = Dhis2:DataElement.create(elements)
+      { name: "TesTesT1", short_name: "TTT1" },
+      { name: "TesTesT2", short_name: "TTT2" }
+    ]
+    status = Dhis2.client.data_elements.create(elements)
     status.success? # => true
     status.total_imported # => 2
 
 DHIS2 API does not return the ids of the created elements, but you can retreive them with their (unique) name or code.
 
+    elements = [
+      { name: "TesTesT2", short_name: "TTT2" }
+    ]
+    status = Dhis2.client.data_elements.create(elements)
+    element = Dhis2.client.data_elements.find_by(name: "TesTesT2")
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. Note that the tests are using the DHIS2 demo server, which is reset every day but can be updated by anyone - so if someone change the password of the default user, the tests are going to fail.
@@ -101,5 +153,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/BLSQ/d
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-
-z

data/lib/dhis2/api/analytic.rb

@@ -0,0 +1,16 @@
+module Dhis2
+  module Api
+    class Analytic < Base
+      class << self
+        def list(client, periods:, organisation_units:, data_elements:)
+          params = RestClient::ParamsArray.new([
+            [:dimension, "ou:#{organisation_units}"],
+            [:dimension, "dx:#{data_elements}"],
+            [:dimension, "pe:#{periods}"]
+          ])
+          client.get(self.resource_name, params)
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/base.rb

@@ -0,0 +1,104 @@
+module Dhis2
+  module Api
+    class Base < OpenStruct
+      class << self
+        def inherited(base)
+          Dhis2::Client.register_resource(base)
+        end
+
+        def find(client, id, options = {})
+          raise "Missing id" if id.nil?
+
+          if id.class == Array
+            list(client, filter: "id:in:[#{id.join(',')}]", fields: :all, page_size: id.size)
+          elsif options.any?
+            params = []
+            options.each do |name, value|
+              params << [name, value]
+            end
+            params        = client.class.deep_change_case(params, :camelize)
+            json_response = client.get("#{resource_name}/#{id}", RestClient::ParamsArray.new(params))
+            new(client, json_response)
+          else
+            response = client.get("#{resource_name}/#{id}")
+            new(client, response)
+          end
+        end
+
+        def find_by(client, clauses)
+          filter = []
+          clauses.each do |field, value|
+            filter << "#{field}:eq:#{value}"
+          end
+          list(client, fields: :all, filter: filter).first
+        end
+
+        def list(client, options = {})
+          json_response = client.get(resource_name, format_query_parameters(options))
+          resource_key  = client.class.underscore(resource_name)
+          PaginatedArray.new(
+            json_response[resource_key].map { |raw_resource| new(client, raw_resource) },
+            json_response["pager"]
+          )
+        end
+
+        def resource_name
+          simple_name = name.split("::").last
+          simple_name[0].downcase + simple_name[1..-1] + "s"
+        end
+
+        def format_query_parameters(options)
+          params = []
+          params.push([:page, options[:page]])                    if options[:page]
+          params.push([:pageSize, options[:page_size]])           if options[:page_size]
+          params.push([:fields, format_fields(options[:fields])]) if options[:fields]
+          params.concat(format_filter(options[:filter]))          if options[:filter]
+
+          RestClient::ParamsArray.new(params)
+        end
+
+        def format_fields(fields)
+          if fields.respond_to?(:join)
+            fields.join(",")
+          elsif fields == :all
+            ":all"
+          else
+            fields
+          end
+        end
+
+        def format_filter(filter)
+          if filter.respond_to?(:map)
+            filter.map do |subfilter|
+              [:filter, subfilter]
+            end
+          else
+            [[:filter, filter]]
+          end
+        end
+      end
+
+      def initialize(client, raw_data)
+        super(raw_data)
+        self.client = client
+      end
+
+      def update_attributes(attributes)
+        client.patch("#{self.class.resource_name}/#{id}", attributes)
+        attributes.each do |key, value|
+          self[key] = value
+        end
+        self
+      end
+
+      def delete
+        client.delete("#{self.class.resource_name}/#{id}")
+        true
+      end
+
+      def ==(other)
+        self.class == other.class && id == other.id
+      end
+    end
+  end
+end

data/lib/dhis2/api/category_combo.rb

@@ -0,0 +1,26 @@
+module Dhis2
+  module Api
+    class CategoryCombo < Base
+      class << self
+        def defaut
+          find_by(name: "default")
+        end
+
+        def create(client, combos)
+          combos = [combos].flatten
+          category_combo = {
+            categoryCombos: combos.map do |combo|
+              {
+                name:                combo[:name],
+                data_dimension_type: combo[:aggregation_type] || "DISAGGREGATION"
+              }
+            end
+          }
+
+          response = client.post("metadata", category_combo)
+          Dhis2::Status.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/data_element.rb

@@ -0,0 +1,31 @@
+module Dhis2
+  module Api
+    class DataElement < Base
+      class << self
+        def create(client, elements)
+          elements          = [elements].flatten
+          category_combo_id = client.category_combos.find_by(name: "default").id
+
+          data_element = {
+            data_elements: elements.map do |element|
+              {
+                name:             element[:name],
+                short_name:       element[:short_name],
+                code:             element[:code] || element[:short_name],
+                domain_type:      element[:domain_type] || "AGGREGATE",
+                value_type:       element[:value_type] || "NUMBER",
+                aggregation_type: element[:aggregation_type] || "SUM",
+                type:             element[:type] || "int", # for backward compatbility
+                aggregation_operator: element[:aggregation_type] || "SUM", # for backward compatbility
+                category_combo:   { id: category_combo_id }
+              }
+            end
+          }
+
+          response = client.post("metadata", data_element)
+          Dhis2::Status.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/data_element_group.rb

@@ -0,0 +1,22 @@
+module Dhis2
+  module Api
+    class DataElementGroup < Base
+      class << self
+        def create(client, groups)
+          groups = [groups].flatten
+          de_groups = {
+            data_element_groups: groups.map do |group|
+              {
+                name:       group[:name],
+                short_name: group[:short_name],
+                code:       group[:code] || group[:short_name]
+              }
+            end
+          }
+          response = client.post("metadata", de_groups)
+          Dhis2::Status.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/data_set.rb

@@ -0,0 +1,25 @@
+module Dhis2
+  module Api
+    class DataSet < Base
+      class << self
+        def create(client, sets)
+          sets     = [sets].flatten
+          data_set = {
+            data_sets: sets.map do |set|
+              {
+                name:               set[:name],
+                short_name:         set[:short_name],
+                code:               set[:code],
+                period_type:        "Monthly",
+                data_elements:      set[:data_element_ids] ? set[:data_element_ids].map { |id| { id: id } } : [],
+                organisation_units: set[:organisation_unit_ids] ? set[:organisation_unit_ids].map { |id| { id: id } } : []
+              }
+            end
+          }
+          response = client.post("metadata", data_set)
+          Dhis2::Status.new(response)
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/data_value.rb

@@ -0,0 +1,13 @@
+module Dhis2
+  module Api
+    class DataValue < Base
+      class << self
+        def find(client, period:, organisation_unit:, data_element:)
+          params = { pe: period, ou: organisation_unit, de: data_element }
+
+          client.get(self.resource_name, params).first
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/data_value_set.rb

@@ -0,0 +1,39 @@
+module Dhis2
+  module Api
+    class DataValueSet < Base
+      def values
+        data_values.map do |data_value|
+          OpenStruct.new(data_value)
+        end
+      end
+
+      class << self
+        def create(client, tuples)
+          body = { dataValues: tuples }
+          response = client.post(self.resource_name, body)
+          Dhis2::Status.new(response)
+        end
+
+        def list(client, options)
+          data_set_ids         = options[:data_sets]
+          periods              = options[:periods]
+
+          organisation_unit_id = options[:organisation_unit]
+          children             = options[:children] || true
+
+          if organisation_unit_id.class == Array
+            ou_url = organisation_unit_id.map { |ou_id| "orgUnit=#{ou_id}" }.join("&") + "&children=#{children}"
+          else
+            ou_url = "orgUnit=#{organisation_unit_id}&children=#{children}"
+          end
+
+          data_sets_url = data_set_ids.map { |ds| "dataSet=#{ds}" }.join("&")
+          periods       = periods.map { |period| "period=#{period}" }.join("&")
+
+          params = [data_sets_url, periods, ou_url].join("&")
+          new(client, client.get(self.resource_name + "?" + params))
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/indicator.rb

@@ -0,0 +1,6 @@
+module Dhis2
+  module Api
+    class Indicator < Base
+    end
+  end
+end

data/lib/dhis2/api/organisation_unit.rb

@@ -0,0 +1,68 @@
+module Dhis2
+  module Api
+    class OrganisationUnit < Base
+      def initialize(client, params)
+        super
+        self.parent_id    = params["parent"]["id"] if params["parent"]
+        self.children_ids = params["children"] ? params["children"].map { |raw| raw["id"] } : []
+      end
+
+      class << self
+        def find(client, id, options = {})
+          raise "Missing id" if id.nil?
+          if id.class == Array
+            list(client, filter: "id:in:[#{id.join(',')}]", fields: :all, page_size: id.size)
+          elsif options.any?
+            params = []
+            options.each do |name, value|
+              params << [name, value]
+            end
+            params        = client.class.deep_change_case(params, :camelize)
+            json_response = client.get("#{resource_name}/#{id}", RestClient::ParamsArray.new(params))
+            if options[:include_descendants] || options[:include_children]
+              json_response = client.get(resource_name, format_query_parameters(options))
+              resource_key  = client.class.underscore(resource_name)
+              PaginatedArray.new(
+                json_response[resource_key].map { |raw_resource| new(client, raw_resource) },
+                json_response["pager"]
+              )
+            else
+              new(client, json_response)
+            end
+          else
+            response = client.get("#{resource_name}/#{id}")
+            new(client, response)
+          end
+        end
+
+        def create(client, orgunits)
+          orgunits = [orgunits].flatten
+
+          payload = {
+            organisationUnits: orgunits.map do |orgunit|
+              organisation_unit = {
+                name:        orgunit[:name],
+                short_name:   orgunit[:short_name],
+                opening_date: orgunit[:opening_date]
+              }
+              organisation_unit[:parent] = {id: orgunit[:parent_id]} if orgunit[:parent_id] 
+              organisation_unit
+            end
+          }
+
+          response = client.post("metadata", payload)
+          Dhis2::Status.new(response)
+        end
+
+        def last_level_descendants(client, id)
+          levels     = client.organisation_unit_levels.list(fields: :all)
+          last_level = levels.map(&:level).sort.last
+
+          client.organisation_units.find(id, include_descendants: true).select do |ou|
+            ou.level == last_level
+          end
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/organisation_unit_group.rb

@@ -0,0 +1,11 @@
+module Dhis2
+  module Api
+    class OrganisationUnitGroup < Base
+      def organisation_unit_ids
+        organisation_units.map do |organisation_unit|
+          organisation_unit["id"]
+        end
+      end
+    end
+  end
+end

data/lib/dhis2/api/organisation_unit_level.rb

@@ -0,0 +1,6 @@
+module Dhis2
+  module Api
+    class OrganisationUnitLevel < Base
+    end
+  end
+end

data/lib/dhis2/client.rb

@@ -0,0 +1,114 @@
+module Dhis2
+  class Client
+    def self.register_resource(resource_class)
+      class_name  = resource_class.name.split("::").last
+      method_name = underscore(class_name) + "s"
+      define_method(method_name) do
+        CollectionWrapper.new(resource_class, self)
+      end
+    end
+
+    def self.deep_change_case(hash, type)
+      case hash
+      when Array
+        hash.map {|v| deep_change_case(v, type) }
+      when Hash
+        new_hash = {}
+        hash.each do |k, v|
+          new_key = type == :underscore ? underscore(k.to_s) : camelize(k.to_s, false)
+          new_hash[new_key] = deep_change_case(v, type)
+        end
+        new_hash
+      else
+        hash
+      end
+    end
+
+    def self.camelize(string, uppercase_first_letter = true)
+      if uppercase_first_letter
+        string = string.sub(/^[a-z\d]*/) { $&.capitalize }
+      else
+        string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
+      end
+      string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
+    end
+
+    def self.underscore(camel_cased_word)
+      return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
+      word = camel_cased_word.to_s.gsub(/::/, '/')
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+
+    def initialize(options)
+      if options.is_a?(String)
+        @base_url = options
+      else
+        raise "Missing :url attribute"      unless options[:url]
+        raise "Missing :user attribute"     unless options[:user]
+        raise "Missing :password attribute" unless options[:password]
+        url          = URI.parse(options[:url])
+        url.user     = CGI.escape(options[:user])
+        url.password = CGI.escape(options[:password])
+        @base_url    = url.to_s
+      end
+    end
+
+    def post(path, payload, query_params = {})
+      execute(:post, uri(path), headers, query_params, payload)
+    end
+
+    def get(path, query_params = {})
+      execute(:get, uri(path), headers, query_params)
+    end
+
+    def delete(path, query_params = {})
+      execute(:delete, uri(path), headers, query_params)
+    end
+
+    def put(path, payload, query_params = {})
+      execute(:put, uri(path), headers, query_params, payload)
+    end
+
+    def patch(path, payload, query_params = {})
+      execute(:patch, uri(path), headers, query_params, payload)
+    end
+
+    private
+
+    def execute(method, url, headers, query_params = {}, payload = nil)
+      query = {
+        method:  method,
+        url:     url,
+        headers: { params: query_params }.merge(headers),
+        payload: payload ? self.class.deep_change_case(payload, :camelize).to_json : nil
+      }
+
+      raw_response = RestClient::Request.execute(query)
+      response     = raw_response.nil? || raw_response == "" ? {} : JSON.parse(raw_response)
+      response     = self.class.deep_change_case(response, :underscore)
+
+      if  response.class == Hash && response["import_type_summaries"] &&
+          response["import_type_summaries"][0] &&
+          response["import_type_summaries"][0]["import_conflicts"] &&
+          !response["import_type_summaries"].first["import_conflicts"].empty?
+        raise Dhis2::ImportError, response["import_type_summaries"].first["import_conflicts"].first["value"].inspect
+      end
+      response
+    end
+
+    def uri(path)
+      File.join(@base_url, "api", path)
+    end
+
+    def headers
+      {
+        content_type: :json,
+        accept:       :json
+      }
+    end
+  end
+end

data/lib/dhis2/collection_wrapper.rb

@@ -0,0 +1,13 @@
+module Dhis2
+  class CollectionWrapper
+    def initialize(klass, client)
+      @klass  = klass
+      @client = client
+    end
+
+    def method_missing(method_name, *args, &block)
+      args = args.unshift(@client)
+      @klass.__send__(method_name, *args, &block)
+    end
+  end
+end

data/lib/dhis2/configuration.rb

@@ -0,0 +1,5 @@
+module Dhis2
+  class Configuration
+    attr_accessor :url, :user, :password
+  end
+end

data/lib/dhis2/import_error.rb

@@ -0,0 +1,4 @@
+module Dhis2
+  class ImportError < StandardError
+  end
+end

data/lib/dhis2/pager.rb

@@ -0,0 +1,10 @@
+class Pager
+  attr_reader :page, :page_count, :total, :next_page
+
+  def initialize(hash)
+    @page       = hash["page"]
+    @page_count = hash["page_count"]
+    @total      = hash["total"]
+    @next_page  = hash["next_page"]
+  end
+end

data/lib/dhis2/paginated_array.rb

@@ -0,0 +1,10 @@
+module Dhis2
+  class PaginatedArray < DelegateClass(Array)
+    attr_reader :pager
+
+    def initialize(array, raw_pager = nil)
+      super(array)
+      @pager = Pager.new(raw_pager) if raw_pager
+    end
+  end
+end

data/lib/dhis2/status.rb

@@ -0,0 +1,34 @@
+module Dhis2
+  class Status
+    attr_reader :raw_status
+
+    def initialize(raw_status)
+      @raw_status = raw_status
+    end
+
+    def success?
+      if @raw_status["import_type_summaries"]
+        return @raw_status["import_type_summaries"].all? do |summary|
+          summary["status"] == "SUCCESS"
+        end
+      end
+      @raw_status["status"] == "SUCCESS"
+    end
+
+    def import_count
+      @raw_status["import_count"]
+    end
+
+    def total_imported
+      total = 0
+      import_count.each do |_, count|
+        total += count
+      end
+      total
+    end
+
+    def last_imported_ids
+      @raw_status["import_type_summaries"].map { |summary| summary["last_imported"] }
+    end
+  end
+end

data/lib/dhis2/version.rb

@@ -1,3 +1,3 @@
 module Dhis2
-  VERSION = "0.1.0"
+  VERSION = "2.1.0"
 end

data/lib/dhis2.rb

@@ -1,47 +1,56 @@
-require "dhis2/version"
 require "rest-client"
 require "json"
-require "organisation_unit"
-require "data_element"
-require "data_set"
-require "organisation_unit_level"
-require "status"
-require "paginated_array"
+require "ostruct"
+require "uri"
+require "delegate"
+require "cgi"
 
-module Dhis2
-  class << self
-    attr_reader :url
+require_relative "dhis2/version"
+require_relative "dhis2/configuration"
+require_relative "dhis2/collection_wrapper"
+require_relative "dhis2/pager"
+require_relative "dhis2/paginated_array"
+require_relative "dhis2/import_error"
+require_relative "dhis2/status"
+require_relative "dhis2/client"
 
-    def connect(options)
-      raise "Missing #{url}" unless options[:url]
-      raise "Missing #{user}" unless options[:user]
-      raise "Missing #{password}" unless options[:password]
-
-      @url = options[:url]
-      @user = options[:user]
-      @password = options[:password]
-    end
+require_relative "dhis2/api/base"
+require_relative "dhis2/api/category_combo"
+require_relative "dhis2/api/organisation_unit"
+require_relative "dhis2/api/data_element"
+require_relative "dhis2/api/data_element_group"
+require_relative "dhis2/api/data_set"
+require_relative "dhis2/api/data_value_set"
+require_relative "dhis2/api/data_value"
+require_relative "dhis2/api/organisation_unit_level"
+require_relative "dhis2/api/indicator"
+require_relative "dhis2/api/analytic"
+require_relative "dhis2/api/organisation_unit_group"
 
-    def get_resource(name, options = {})
-      arguments = []
-      if options[:fields]
-        arguments << "fields=" + options[:fields].join(",") if options[:fields].respond_to?(:join)
-        arguments << "fields=:#{options[:fields]}" if options[:fields].class == Symbol
+module Dhis2
+  class << self
+    def client
+      if @client.nil?
+        if config.user.nil? && config.password.nil?
+          @client ||= Dhis2::Client.new(config.url)
+        else
+          @client ||= Dhis2::Client.new({
+            url:      config.url,
+            user:     config.user,
+            password: config.password
+          })
+        end
+      else
+        @client
       end
-      arguments << "filter=" + options[:filter] if options[:filter]
-      arguments << "pageSize=#{options[:page_size]}" if options[:page_size]
-      arguments << "page=#{options[:page]}" if options[:page]
-
-      path = "#{name}?#{arguments.join('&')}"
-      resource[path]
     end
 
-    def resource
-      @resource ||= RestClient::Resource.new("#{@url}/api", headers: { accept: "application/json" }, user: @user, password: @password)
+    def configure(&block)
+      yield config
     end
 
-    def camelize(str)
-      str.gsub(/\_([a-z])/, "")
+    def config
+      @configuration ||= Dhis2::Configuration.new
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dhis2
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Martin Van Aken
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-29 00:00:00.000000000 Z
+date: 2016-10-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -85,16 +85,27 @@ files:
 - bin/console
 - bin/setup
 - dhis2.gemspec
-- lib/base.rb
-- lib/data_element.rb
-- lib/data_set.rb
 - lib/dhis2.rb
+- lib/dhis2/api/analytic.rb
+- lib/dhis2/api/base.rb
+- lib/dhis2/api/category_combo.rb
+- lib/dhis2/api/data_element.rb
+- lib/dhis2/api/data_element_group.rb
+- lib/dhis2/api/data_set.rb
+- lib/dhis2/api/data_value.rb
+- lib/dhis2/api/data_value_set.rb
+- lib/dhis2/api/indicator.rb
+- lib/dhis2/api/organisation_unit.rb
+- lib/dhis2/api/organisation_unit_group.rb
+- lib/dhis2/api/organisation_unit_level.rb
+- lib/dhis2/client.rb
+- lib/dhis2/collection_wrapper.rb
+- lib/dhis2/configuration.rb
+- lib/dhis2/import_error.rb
+- lib/dhis2/pager.rb
+- lib/dhis2/paginated_array.rb
+- lib/dhis2/status.rb
 - lib/dhis2/version.rb
-- lib/organisation_unit.rb
-- lib/organisation_unit_level.rb
-- lib/pager.rb
-- lib/paginated_array.rb
-- lib/status.rb
 homepage: http://github.com/blsq/dhis2
 licenses:
 - MIT

data/lib/base.rb

@@ -1,49 +0,0 @@
-module Dhis2
-  class Base
-    def initialize(raw_data)
-      @raw_data = raw_data
-      @id = raw_data["id"]
-      @display_name = raw_data["displayName"]
-    end
-
-    def method_missing(m, *args, &block)
-      return @raw_data[m.to_s] if @raw_data[m.to_s]
-      super
-    end
-
-    class << self
-      def find(id)
-        response = Dhis2.get_resource("#{resource_name}/#{id}").get
-        json_response = JSON.parse(response)
-        new(json_response)
-      end
-
-      def find_by(clauses)
-        filter = []
-        clauses.each do |field, value|
-          filter << "#{field}:eq:#{value}"
-        end
-        list(fields: :all, filter: filter.join("&")).first
-      end
-
-      def list(options = {})
-        options[:fields] = default_fields if default_fields && !options[:fields]
-        response = Dhis2.get_resource(resource_name, options).get
-        json_response = JSON.parse(response)
-        PaginatedArray.new(
-          json_response[resource_name].map { |raw_org_unit| new(raw_org_unit) },
-          json_response["pager"]
-        )
-      end
-
-      def resource_name
-        simple_name = name.split("::").last
-        simple_name[0].downcase + simple_name[1..-1] + "s"
-      end
-
-      def default_fields
-        nil
-      end
-    end
-  end
-end

data/lib/data_element.rb

@@ -1,39 +0,0 @@
-require "base"
-
-module Dhis2
-  class DataElement < Base
-    attr_reader :id, :display_name
-
-    def initialize(params)
-      super(params)
-    end
-
-    class << self
-      def create(elements)
-        elements = [elements].flatten
-        category_combo_id = JSON.parse(Dhis2.resource["categoryCombos"].get)["categoryCombos"]
-                            .first["id"]
-        data_element = {
-          dataElements: elements.map do |element|
-            {
-              name:            element[:name],
-              shortName:       element[:short_name],
-              code:            element[:code] || element[:short_name],
-              domainType:      element[:domain_type] || "AGGREGATE",
-              valueType:       element[:value_type] || "INTEGER_POSITIVE",
-              aggregationType: element[:aggregation_type] || "SUM",
-              categoryCombo:   { id: category_combo_id }
-            }
-          end
-        }
-        json_response = Dhis2.resource["metadata"].post(
-          JSON.generate(data_element),
-          content_type: "application/json"
-        )
-        response = JSON.parse(json_response)
-
-        Dhis2::Status.new(response)
-      end
-    end
-  end
-end

data/lib/data_set.rb

@@ -1,35 +0,0 @@
-require "base"
-
-module Dhis2
-  class DataSet < Base
-    def initialize(params)
-      super(params)
-    end
-
-    class << self
-      def create(sets)
-        sets = [sets].flatten
-
-        data_set = {
-          dataSets: sets.map do |set|
-            {
-              name:              set[:name],
-              shortName:         set[:short_name],
-              code:              set[:code],
-              periodType:        "Monthly",
-              dataElements:      set[:data_element_ids] ? set[:data_element_ids].map { |id| { id: id } } : [],
-              organisationUnits: set[:organisation_unit_ids] ? set[:organisation_unit_ids].map { |id| { id: id } } : []
-            }
-          end
-        }
-        json_response = Dhis2.resource["metadata"].post(
-          JSON.generate(data_set),
-          content_type: "application/json"
-        )
-        response = JSON.parse(json_response)
-
-        Dhis2::Status.new(response)
-      end
-    end
-  end
-end

data/lib/organisation_unit.rb

@@ -1,14 +0,0 @@
-require "base"
-
-module Dhis2
-  class OrganisationUnit < Base
-    attr_reader :id, :display_name, :level, :parent_id, :children_ids
-
-    def initialize(params)
-      super(params)
-      @level = params["level"]
-      @parent_id = params["parent"]["id"] if params["parent"]
-      @children_ids = params["children"] ? params["children"].map { |raw| raw["id"] } : []
-    end
-  end
-end

data/lib/organisation_unit_level.rb

@@ -1,19 +0,0 @@
-require "base"
-
-module Dhis2
-  class OrganisationUnitLevel < Base
-    attr_reader :id, :name, :level
-
-    def initialize(params)
-      super(params)
-      @name = params["name"]
-      @level = params["level"]
-    end
-
-    class << self
-      def default_fields
-        %w(id name level)
-      end
-    end
-  end
-end

data/lib/pager.rb

@@ -1,10 +0,0 @@
-class Pager
-  attr_reader :page, :page_count, :total, :next_page
-
-  def initialize(hash)
-    @page = hash["page"]
-    @page_count = hash["pageCount"]
-    @total = hash["total"]
-    @next_page = hash["nextPage"]
-  end
-end

data/lib/paginated_array.rb

@@ -1,11 +0,0 @@
-require "delegate"
-require "pager"
-
-class PaginatedArray < DelegateClass(Array)
-  attr_reader :pager
-
-  def initialize(array, raw_pager = nil)
-    super(array)
-    @pager = Pager.new(raw_pager) if raw_pager
-  end
-end

data/lib/status.rb

@@ -1,53 +0,0 @@
-module Dhis2
-  class Status
-    attr_reader :raw_status
-
-    def initialize(raw_status)
-      @raw_status = raw_status
-    end
-
-    def success?
-      @raw_status["importTypeSummaries"].all? { |summary| summary["status"] == "SUCCESS" }
-    end
-
-    def import_count
-      @raw_status["importCount"]
-    end
-
-    def total_imported
-      total = 0
-      import_count.each do |_, count|
-        total += count
-      end
-      total
-    end
-
-    def last_imported_ids
-      @raw_status["importTypeSummaries"].map { |summary| summary["lastImported"] }
-    end
-  end
-end
-
-# {
-#   "importCount"=>{
-#     "imported"=>1, 
-#     "updated"=>0, 
-#     "ignored"=>0, 
-#     "deleted"=>0
-#   }, 
-#   "importTypeSummaries"=>[
-#     {
-#       "responseType"=>"ImportTypeSummary", 
-#       "status"=>"SUCCESS", 
-#       "importCount"=>
-#       {
-#         "imported"=>1, 
-#         "updated"=>0, 
-#         "ignored"=>0, 
-#         "deleted"=>0
-#       }, 
-#       "type"=>"DataElement", 
-#       "lastImported"=>"lMadHjxdo5q"
-#     }
-#   ]
-# }