dhis2 2.3.8 → 3.0.0

data/lib/dhis2/client.rb

@@ -2,126 +2,189 @@
 
 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
+    attr_reader :version
+
+    def initialize(options)
+      @base_url   = options.fetch(:url)
+      @version    = options.fetch(:version)
+      @verify_ssl = options.fetch(:verify_ssl, OpenSSL::SSL::VERIFY_PEER)
+      @timeout    = options.fetch(:timeout, 120)
+      @debug      = options.fetch(:debug, false)
     end
-    SUPPORTER_CASE_CHANGES = %i[underscore camelize].freeze
-
-    def self.deep_change_case(hash, type)
-      raise "unsupported case changes #{type} vs #{SUPPORTER_CASE_CHANGES}" unless SUPPORTER_CASE_CHANGES.include?(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
+
+    def post(path:, payload: nil, query_params: {}, raw: false, raw_input: false)
+      execute(method_name: :post, url: uri(path), query_params: query_params, payload: payload, raw: raw, raw_input: raw_input)
     end
 
-    def self.camelize(string, uppercase_first_letter = true)
-      string = if uppercase_first_letter
-                 string.sub(/^[a-z\d]*/) { $&.capitalize }
-               else
-                 string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { $&.downcase }
-               end
-      string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{Regexp.last_match(1)}#{Regexp.last_match(2).capitalize}" }.gsub("/", "::")
+    def get(path:, query_params: {}, raw: false)
+      execute(method_name: :get, url: uri(path), query_params: query_params, raw: raw)
     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
+    def delete(path:, query_params: {}, raw: false)
+      execute(method_name: :delete, url: uri(path), query_params: query_params, raw: raw)
     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
-        @verify_ssl = options[:no_ssl_verification] ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
-        @timeout = options[:timeout] ? options[:timeout].to_i : 120
-        @debug = options[:debug] && options[:debug] == true
-      end
+    def put(path:, payload:, query_params: {}, raw: false)
+      execute(method_name: :put, url: uri(path), query_params: query_params, payload: payload, raw: raw)
     end
 
-    def post(path, payload = nil, query_params = {})
-      execute(:post, uri(path), headers, query_params, payload)
+    def patch(path:, payload:, query_params: {}, raw: false)
+      execute(method_name: :patch, url: uri(path), query_params: query_params, payload: payload, raw: raw)
     end
 
-    def get(path, query_params = {})
-      execute(:get, uri(path), headers, query_params)
+    def analytics
+      @analytics ||= CollectionWrapper.new("Analytic", self)
     end
 
-    def delete(path, query_params = {})
-      execute(:delete, uri(path), headers, query_params)
+    def attributes
+      @attributes ||= CollectionWrapper.new("Attribute", self)
     end
 
-    def put(path, payload, query_params = {})
-      execute(:put, uri(path), headers, query_params, payload)
+    def category_combos
+      @category_combos ||= CollectionWrapper.new("CategoryCombo", self)
     end
 
-    def patch(path, payload, query_params = {})
-      execute(:patch, uri(path), headers, query_params, payload)
+    def category_option_combos
+      @category_option_combos ||= CollectionWrapper.new("CategoryOptionCombo", self)
     end
 
-    private
+    def data_elements
+      @data_elements ||= CollectionWrapper.new("DataElement", self)
+    end
 
-    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,
-        verify_ssl: @verify_ssl,
-        timeout:    @timeout
-      }
+    def data_element_groups
+      @data_element_groups ||= CollectionWrapper.new("DataElementGroup", self)
+    end
 
-      raw_response = RestClient::Request.execute(query)
+    def data_sets
+      @data_sets ||= CollectionWrapper.new("DataSet", self)
+    end
 
-      response = raw_response.nil? || raw_response == "" ? {} : JSON.parse(raw_response)
+    def data_values
+      @data_values ||= CollectionWrapper.new("DataValue", self)
+    end
+
+    def data_value_sets
+      @data_value_sets ||= CollectionWrapper.new("DataValueSet", self)
+    end
+
+    def events
+      @events ||= CollectionWrapper.new("Event", self)
+    end
+
+    def indicators
+      @indicators ||= CollectionWrapper.new("Indicator", self)
+    end
 
-      puts [raw_response.request.url, query[:payload], response].join("\t") if @debug
+    def indicator_groups
+      @indicator_groups ||= CollectionWrapper.new("IndicatorGroup", self)
+    end
 
-      response = self.class.deep_change_case(response, :underscore)
+    def indicator_types
+      @indicator_types ||= CollectionWrapper.new("IndicatorType", self)
+    end
+
+    def organisation_units
+      @organisation_units ||= CollectionWrapper.new("OrganisationUnit", self)
+    end
+
+    def organisation_unit_groups
+      @organisation_unit_groups ||= CollectionWrapper.new("OrganisationUnitGroup", self)
+    end
+
+    def organisation_unit_group_sets
+      @organisation_unit_group_sets ||= CollectionWrapper.new("OrganisationUnitGroupSet", self)
+    end
 
-      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
+    def organisation_unit_levels
+      @organisation_unit_levels ||= CollectionWrapper.new("OrganisationUnitLevel", self)
+    end
+
+    def programs
+      @programs ||= CollectionWrapper.new("Program", self)
+    end
+
+    def reports
+      @reports ||= CollectionWrapper.new("Report", self)
+    end
+
+    def report_tables
+      @report_tables ||= CollectionWrapper.new("ReportTable", self)
+    end
+
+    def resource_tables
+      @resource_tables ||= CollectionWrapper.new("ResourceTable", self)
+    end
+
+    def system_infos
+      @system_infos ||= CollectionWrapper.new("SystemInfo", self)
+    end
+
+    def users
+      @users ||= CollectionWrapper.new("User", self)
+    end
+
+    def can_connect?
+      system_infos.get
+      true
+    rescue ::Dhis2::Error
+      false
+    rescue StandardError
+      false
+    end
+
+    def self.uri(base_url, path)
+      File.join(base_url, API, path)
+    end
+
+    private
+
+    EMPTY_RESPONSES = [nil, ""]
+    API =  "api"
+    TAB = "\t"
+
+    def execute(method_name:, url:, query_params: {}, payload: nil, raw: false, raw_input: false)
+      raw_response = RestClient::Request.execute(
+        method:     method_name,
+        url:        url,
+        headers:    headers(method_name, query_params),
+        payload:    compute_payload(payload, raw_input),
+        verify_ssl: @verify_ssl,
+        timeout:    @timeout
+      )
+      response = EMPTY_RESPONSES.include?(raw_response) ? {} : JSON.parse(raw_response)
+      log(raw_response.request, response)
+      if raw
+        response
+      else
+        Dhis2::Case.deep_change(response, :underscore)
       end
-      response
+    rescue RestClient::RequestFailed => e
+      exception = ::Dhis2::RequestError.new(e.message)
+      exception.response  = e.response  if e.respond_to?(:response)
+      exception.http_code = e.http_code if e.respond_to?(:http_code)
+      exception.http_body = e.http_body if e.respond_to?(:http_body)
+      raise exception
+    end
+
+    def compute_payload(payload, raw_input)
+      return nil unless payload
+      return payload.to_json if raw_input
+      Dhis2::Case.deep_change(payload, :camelize).to_json
     end
 
     def uri(path)
-      File.join(@base_url, "api", path)
+      self.class.uri(@base_url, path)
+    end
+
+    def headers(method_name, query_params)
+      { params: query_params, accept: :json }.tap do |hash|
+        hash[:content_type] = :json unless method_name == :get
+      end
     end
 
-    def headers
-      {
-        content_type: :json,
-        accept:       :json
-      }
+    def log(request, response)
+      puts [request.url, request.args[:payload], response].join(TAB) if @debug
     end
   end
 end

data/lib/dhis2/collection_wrapper.rb

@@ -2,14 +2,24 @@
 
 module Dhis2
   class CollectionWrapper
-    def initialize(klass, client)
-      @klass  = klass
+    def initialize(resource_name, client)
+      @klass  = get_resource_klass(resource_name)[client.version]
       @client = client
     end
 
     def method_missing(method_name, *args, &block)
       args = args.unshift(@client)
-      @klass.__send__(method_name, *args, &block)
+      @klass.public_send(method_name, *args, &block)
+    end
+
+    def respond_to_missing?(method_name)
+      @klass.respond_to? method_name
+    end
+
+    private
+
+    def get_resource_klass(resource_name)
+      Object.const_get "Dhis2::#{resource_name}"
     end
   end
 end

data/lib/dhis2/configuration.rb

@@ -2,6 +2,60 @@
 
 module Dhis2
   class Configuration
-    attr_accessor :url, :user, :password, :debug
+    ALLOWED_VERSIONS = %w(2.24 2.25 2.26 2.27 2.28).freeze
+
+    attr_accessor :url, :user, :password, :debug, :no_ssl_verification, :timeout
+
+    def client_params
+      {
+        url:        no_credentials? ? url : build_url,
+        debug:      debug,
+        version:    version,
+        timeout:    timeout,
+        verify_ssl: verify_ssl
+      }
+    end
+
+    def play_params(with_debug)
+      {
+        url:     "https://admin:district@play.dhis2.org/2.28/",
+        debug:   with_debug,
+        version: "2.28"
+      }
+    end
+
+    def version=(version)
+      raise Dhis2::InvalidVersionError, version.to_s unless ALLOWED_VERSIONS.include?(version)
+      @version = version
+    end
+
+    private
+
+    def verify_ssl
+      if no_ssl_verification
+        OpenSSL::SSL::VERIFY_NONE
+      else
+        OpenSSL::SSL::VERIFY_PEER
+      end
+    end
+
+    def version
+      @version || default_version
+    end
+
+    def default_version
+      ALLOWED_VERSIONS.last
+    end
+
+    def no_credentials?
+      user.nil? && password.nil?
+    end
+
+    def build_url
+      URI.parse(url).tap do |url|
+        url.user     = CGI.escape(user)
+        url.password = CGI.escape(password)
+      end.to_s
+    end
   end
 end

data/lib/dhis2/error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Dhis2
+  class Error < StandardError; end
+  class BulkCreationError < Error
+    attr_accessor :import_summary
+  end
+  class CreationError < Error; end
+  class UpdateError   < Error; end
+  class PrimaryKeyMissingError < Error; end
+  class InvalidRequestError < Error; end
+  class CaseError < Error; end
+  class InvalidVersionError < Error; end
+  class InvalidMethodError < Error; end
+  class DataElementAdditionError < Error; end
+  class RequestError < Error
+    attr_accessor :response, :http_code, :http_body
+  end
+end

data/lib/dhis2/pager.rb

@@ -2,13 +2,18 @@
 
 module Dhis2
   class Pager
-    attr_reader :page, :page_count, :total, :next_page
+    attr_reader :page, :page_count, :total, :next_page, :page_size
 
     def initialize(hash)
       @page       = hash["page"]
-      @page_count = hash["page_count"]
+      @page_count = hash["page_count"] || hash["pageCount"]
       @total      = hash["total"]
-      @next_page  = hash["next_page"]
+      @next_page  = hash["next_page"] || hash["nextPage"]
+      @page_size  = hash["page_size"] || hash["pageSize"]
+    end
+
+    def last_page?
+      page * page_size >= total
     end
   end
 end

data/lib/dhis2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Dhis2
-  VERSION = "2.3.8"
+  VERSION = "3.0.0"
 end

data/lib/dhis2.rb

@@ -6,64 +6,60 @@ require "ostruct"
 require "uri"
 require "delegate"
 require "cgi"
+require "dry-validation"
 
 require_relative "dhis2/version"
+require_relative "dhis2/case"
+require_relative "dhis2/error"
 require_relative "dhis2/configuration"
+require_relative "dhis2/classes"
 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"
 
 require_relative "dhis2/api/base"
-require_relative "dhis2/api/category_combo"
-require_relative "dhis2/api/category_option_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/indicator_group"
-require_relative "dhis2/api/analytic"
-require_relative "dhis2/api/organisation_unit_group"
-require_relative "dhis2/api/organisation_unit_group_set"
-require_relative "dhis2/api/system_info"
-require_relative "dhis2/api/attribute"
-require_relative "dhis2/api/user"
-require_relative "dhis2/api/event"
-require_relative "dhis2/api/program"
-require_relative "dhis2/api/report_table"
-require_relative "dhis2/api/resource_table"
-require_relative "dhis2/api/report"
+require_relative "dhis2/api/import_summary"
+require_relative "dhis2/api/event_creation_status"
+require_relative "dhis2/api/constants"
+require_relative "dhis2/api/bulk_creatable"
+require_relative "dhis2/api/creatable"
+require_relative "dhis2/api/deletable"
+require_relative "dhis2/api/listable"
+require_relative "dhis2/api/findable"
+require_relative "dhis2/api/updatable"
+require_relative "dhis2/api/query_parameters_formatter"
+
+require_relative "dhis2/api/shared/analytic"
+require_relative "dhis2/api/shared/category_combo"
+require_relative "dhis2/api/shared/category_option_combo"
+require_relative "dhis2/api/shared/constants"
+require_relative "dhis2/api/shared/data_element_group"
+require_relative "dhis2/api/shared/data_set"
+require_relative "dhis2/api/shared/data_value"
+require_relative "dhis2/api/shared/data_value_set"
+require_relative "dhis2/api/shared/event"
+require_relative "dhis2/api/shared/organisation_unit"
+require_relative "dhis2/api/shared/organisation_unit_group"
+require_relative "dhis2/api/shared/report_tables"
+require_relative "dhis2/api/shared/resource_table"
+require_relative "dhis2/api/shared/save_validator"
+require_relative "dhis2/api/shared/system_info"
+
+require_relative "dhis2/api/version224/index"
+require_relative "dhis2/api/version225/index"
+require_relative "dhis2/api/version226/index"
+require_relative "dhis2/api/version227/index"
+require_relative "dhis2/api/version228/index"
 
 module Dhis2
   class << self
     def play(debug = false)
-      Dhis2::Client.new(
-        url:      "https://play.dhis2.org/demo/",
-        user:     "admin",
-        password: "district",
-        debug:    debug
-      )
+      Dhis2::Client.new(config.play_params(debug))
     end
 
     def client
-      if @client.nil?
-        @client ||= if config.user.nil? && config.password.nil?
-                      Dhis2::Client.new(config.url)
-                    else
-                      Dhis2::Client.new(url:      config.url,
-                                        user:     config.user,
-                                        password: config.password,
-                                        debug:    config.debug)
-                    end
-      else
-        @client
-      end
+      @client ||= Dhis2::Client.new(config.client_params)
     end
 
     def configure
@@ -73,5 +69,18 @@ module Dhis2
     def config
       @configuration ||= Dhis2::Configuration.new
     end
+
+    # params: { user: , password:, url: }
+    def get_version(params)
+      check_config = Dhis2::Configuration.new.tap do |conf|
+        conf.url      = params.fetch(:url)
+        conf.password = params.fetch(:password)
+        conf.user     = params.fetch(:user)
+      end
+      response = RestClient.get(
+        Dhis2::Client.uri(check_config.client_params[:url], "/system/info")
+      )
+      JSON.parse(response.body)["version"]
+    end
   end
 end