opencrx 0.0.1 → 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c2784d3b61592f54c1152b468fff93a4642d06e7
+  data.tar.gz: 45d07b8b6bbc135cf3e6fe5ac30bba03ad756e30
+SHA512:
+  metadata.gz: 7489279b7e307aba8727fd2cc77e83ae8224571a9938b813abf53e1af7f14557c6e919552fb0a176d006d3ce9a418a44a45656c0f3d2adfd271e1ffb29cac419
+  data.tar.gz: d1ba221c1eddf2359743f7909b64dfa200851feacabda2f67bf6464e56dc2ce2b2b3d3d1446523413efa392f03f2cbef8fe510c7638aa1714f2d85b29b7957c4

data/.rvmrc

@@ -0,0 +1,60 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional,
+# Only full ruby name is supported here, for short names use:
+#     echo "rvm use 2.0.0" > .rvmrc
+environment_id="ruby-2.0.0-p195@justiz"
+
+# Uncomment the following lines if you want to verify rvm version per project
+# rvmrc_rvm_version="1.20.13 (stable)" # 1.10.1 seams as a safe start
+# eval "$(echo ${rvm_version}.${rvmrc_rvm_version} | awk -F. '{print "[[ "$1*65536+$2*256+$3" -ge "$4*65536+$5*256+$6" ]]"}' )" || {
+#   echo "This .rvmrc file requires at least RVM ${rvmrc_rvm_version}, aborting loading."
+#   return 1
+# }
+
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments"
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+  for __hook in "${rvm_path:-$HOME/.rvm}/hooks/after_use"*
+  do
+    if [[ -f "${__hook}" && -x "${__hook}" && -s "${__hook}" ]]
+    then \. "${__hook}" || true
+    fi
+  done
+  unset __hook
+  if (( ${rvm_use_flag:=1} >= 2 )) # display only when forced
+  then
+    if [[ $- == *i* ]] # check for interactive shells
+    then printf "%b" "Using: \E[32m$GEM_HOME\E[0m" # show the user the ruby and gemset they are using in green
+    else printf "%b" "Using: $GEM_HOME" # don't use colors in non-interactive shells
+    fi
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create  "$environment_id" || {
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  }
+fi
+
+# If you use bundler, this might be useful to you:
+# if [[ -s Gemfile ]] && {
+#   ! builtin command -v bundle >/dev/null ||
+#   builtin command -v bundle | GREP_OPTIONS= \grep $rvm_path/bin/bundle >/dev/null
+# }
+# then
+#   printf "%b" "The rubygem 'bundler' is not installed. Installing it now.\n"
+#   gem install bundler
+# fi
+# if [[ -s Gemfile ]] && builtin command -v bundle >/dev/null
+# then
+#   bundle install | GREP_OPTIONS= \grep -vE '^Using|Your bundle is complete'
+# fi

data/lib/opencrx.rb

@@ -1,141 +1,22 @@
-require "opencrx/version"
-require 'httparty'
-require 'active_support/inflector'
+require 'opencrx/version'
+require 'opencrx/session'
+require 'opencrx/model'
 require 'active_support/core_ext'
 
 module Opencrx
+  class << self
+    attr_accessor :logger, :session
 
-  @@session = nil
-
-  def self.connect(base_url, user, password)
-    self.session = Opencrx::Session.new(base_url, user, password)
-  end
-
-  def self.session
-    @@session
-  end
-
-  def self.session=(object)
-    @@session = object
-  end
-
-  class Session
-    include HTTParty
-
-    #debug_output
-    headers 'Accept' => 'text/xml', 'Content-Type' => 'text/xml'
-    format :xml
-
-    def initialize(base_url, user, password)
-      self.class.base_uri(base_url)
-      self.class.basic_auth(user, password)
-    end
-
-    def get(url, options = {})
-      self.class.get(url, options)
-    end
-
-    def put(url, options = {})
-      self.class.put(url, options)
-    end
-
-    def post(url, options = {})
-      self.class.post(url, options)
-    end
-  end
-
-  module Account
-    SUFFIX = "/opencrx-rest-CRX/org.opencrx.kernel.account1/provider/CRX/segment/Standard/account"
-    KEY = Regexp.new('^org.opencrx.kernel.account1.(.*)$')
-    RESULTSET = 'org.openmdx.kernel.ResultSet'
-
-    def self.get(id)
-      response = session.get(SUFFIX + "/#{id}")
-      #ap Nokogiri.XML(response.body)
-      build_record(response)
-    end
-
-    def self.query(params = {})
-      response = session.get(SUFFIX, query: params)
-      key = response.keys.first
-      if key == RESULTSET
-        parse_resultset(response[key])
-      else
-        failure(response)
-      end
-    end
-
-    def self.post(xml)
-      build_record session.post(SUFFIX, body: xml)
+    def connect(base_url, user, password)
+      self.session = Opencrx::Session.new(base_url, user, password)
     end
 
-    def self.put(url, xml)
-      build_record session.put(url, body: xml)
-    end
-
-    def self.session
-      Opencrx::session
-    end
-
-    def self.parse_resultset(hash)
-      hash.map do |key, value|
-        next if %w(href hasMore).include? key
-        build_record(key => value)
-      end.compact
-    end
-
-    def self.build_record(hash)
-      puts "Expected a single key, got [#{hash.keys}]" unless hash.keys.length == 1
-      key = hash.keys.first
-      key.match(KEY)
-      klass_name = $1
-      if (klass = ActiveSupport::Inflector.safe_constantize("Opencrx::Account::#{klass_name}"))
-        klass.new(hash)
-      else
-        puts "Dont understand record type [#{klass_name}]"
-      end
-    end
-
-    def self.failure(response)
-      ap response.request
-      ap response.response
-      ap response.parsed_response
-      nil
-    end
-
-    class AccountRecord < SimpleDelegator
-      BASEKEY = "org.opencrx.kernel.account1"
-
-      def initialize(attributes)
-        attributes = attributes[key] if attributes.has_key? key
-        super attributes
-      end
-
-      def key
-        "#{BASEKEY}.#{ActiveSupport::Inflector.demodulize self.class}"
-      end
-
-      def save
-        if has_key?('href')
-          Opencrx::Account.put(fetch('href'), xml)
-        else
-          Opencrx::Account.post(xml)
-        end
-      end
-
-      def xml
-        __getobj__.except('owner', 'owningUser', 'owningGroup', 'href', 'version').to_xml(root: key)
+    def logger
+      @logger ||= begin
+        logger = Logger.new(STDERR)
+        logger.level = Logger::WARN
+        logger
       end
     end
-
-    class Contact < AccountRecord
-    end
-    class Group < AccountRecord
-    end
-    class UnspecifiedAccount < AccountRecord
-    end
-    class LegalEntity < AccountRecord
-    end
   end
-
 end

data/lib/opencrx/model.rb

@@ -0,0 +1,12 @@
+require 'opencrx/model/map'
+require 'opencrx/model/result'
+require 'opencrx/model/result_set'
+require 'opencrx/model/record'
+require 'opencrx/model/account'
+require 'opencrx/model/address'
+
+module Opencrx
+  module Model
+    BASE_KEY = "org.opencrx.kernel.account1"
+  end
+end

data/lib/opencrx/model/account.rb

@@ -0,0 +1,30 @@
+module Opencrx
+  module Model
+    class Account < Record
+      have_attributes :aliasName
+
+      def self.provider
+        "#{base_provider}/account"
+      end
+
+      # subrecords of ours include :address
+      def addresses
+        query(:address)
+      end
+    end
+
+    class FilteredAccount < Account
+      def self.default_query_options
+        query_type_option
+      end
+    end
+
+    class LegalEntity < FilteredAccount
+      have_attributes :name
+    end
+
+    class Contact < FilteredAccount; end
+    class Group < FilteredAccount; end
+    class UnspecifiedAccount < FilteredAccount; end
+  end
+end

data/lib/opencrx/model/address.rb

@@ -0,0 +1,47 @@
+module Opencrx
+  module Model
+    class Address < Record
+      # usage is a code
+      USAGE = {
+          mobile: "200",
+          business: "500",
+          fax: "530",
+          visitor: "10500",
+          other: "1800",
+          delivery: "10200"
+      }
+      have_attributes :isMain, :disabled
+      have_array_attributes :usage
+
+      def self.provider
+        "#{base_provider}/address"
+      end
+
+      def assign_to(parent)
+        self.href = "#{parent.href}/address"
+        self.identity = nil
+      end
+    end
+
+    class PostalAddress < Address
+      # postalCountry is a code
+      COUNTRY = {
+          de: "276"
+      }
+      have_attributes :postalCode, :postalCity, :postalState, :postalCountry
+      have_array_attributes :postalAddressLine, :postalStreet
+    end
+
+    class EMailAddress < Address
+      have_attributes :emailAddress
+    end
+
+    class PhoneNumber < Address
+      have_attributes :phoneNumberFull, :automaticParsing
+    end
+
+    class WebAddress < Address
+      have_attributes :webUrl
+    end
+  end
+end

data/lib/opencrx/model/map.rb

@@ -0,0 +1,31 @@
+require 'active_support/inflector'
+
+module Opencrx
+  module Model
+    module Map
+      class << self
+        def opencrx_key_to_model(key)
+          unless key.match(/^#{BASE_KEY}\.(.*)$/)
+            raise "Unexpected key #{key}"
+          end
+          target_class_name = $1
+          ActiveSupport::Inflector.safe_constantize("::Opencrx::Model::#{target_class_name}")
+        end
+
+        def model_to_opencrx_key(klass)
+          "#{BASE_KEY}.#{demodulized_class_name(klass)}"
+        end
+
+        def model_to_opencrx_query(klass)
+          model_to_opencrx_key(klass).gsub(/\./, ':')
+        end
+
+        private
+
+        def demodulized_class_name(klass)
+          ActiveSupport::Inflector.demodulize klass
+        end
+      end
+    end
+  end
+end

data/lib/opencrx/model/record.rb

@@ -0,0 +1,29 @@
+require 'opencrx/model/record/attributes'
+require 'opencrx/model/record/query'
+
+module Opencrx
+  module Model
+    class Record
+      have_attributes :href, :identity
+
+      def save
+        href = attributes['href'] || self.class.query_url
+        response = if attributes['identity']
+                     Opencrx::session.put(href, body: to_xml)
+                   else
+                     Opencrx::session.post(href, body: to_xml)
+                   end
+        Result.parse(response)
+      end
+
+      # TODO implement delete
+      def destroy
+        href = attributes['href']
+        # this errors with No active unit of work
+        #Opencrx::session.delete(href, body: to_xml)
+        # this errors with Premature end of file.
+        #Opencrx::session.delete(href)
+      end
+    end
+  end
+end

data/lib/opencrx/model/record/attributes.rb

@@ -0,0 +1,82 @@
+module Opencrx
+  module Model
+    class Record
+
+      def self.have_attributes(*args)
+        args.each do |arg|
+          define_method(arg) do
+            attribute(arg)
+          end
+          define_method("#{arg}=") do |value|
+            write_attribute(arg, value)
+          end
+        end
+      end
+
+      def self.have_array_attributes(*args)
+        args.each do |arg|
+          define_method(arg) do
+            Array.wrap(attribute(arg))
+          end
+          define_method("#{arg}=") do |value|
+            write_attribute(arg, Array.wrap(value))
+          end
+        end
+      end
+
+      class ItemList < Array
+        def to_xml(options = nil)
+          super(options.merge(children: '_item'))
+        end
+      end
+
+      attr_accessor :attributes
+
+      def initialize(attributes = {})
+        self.attributes = attributes
+      end
+
+      def attributes=(hash)
+        @attributes = {}
+        hash.each do |key, value|
+          write_attribute(key, value)
+        end
+      end
+
+      # store only simple values, or simple arrays.
+      # arrays from opencrx are encoded as a hash values under key '_item'
+      def write_attribute(key, value)
+        key = key.to_s
+        case value
+          # incoming from opencrx
+          when Hash
+            items = Array.wrap(value['_item'])
+            if items.first.is_a?(String)
+              @attributes[key] = ItemList.new(items)
+            end
+          # incoming from our side
+          when Array
+            @attributes[key] = ItemList.new(value)
+          else
+            @attributes[key] = value
+        end
+        @attributes[key]
+      end
+
+      def attribute(key)
+        attributes[key.to_s]
+      end
+
+      def compact
+        attributes.inject({}) do |memo, (key, value)|
+          memo[key] = value if value.present? && value != '0'
+          memo
+        end
+      end
+
+      def to_xml(options = {})
+        attributes.except('href', 'version').to_xml(options.merge(root: Map.model_to_opencrx_key(self.class)))
+      end
+    end
+  end
+end