justiz_sync 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6f1857369597b3596e2d20f889a5651daa81077
+  data.tar.gz: 878761187a610887fde442f878cbf80ca6f0cd43
+SHA512:
+  metadata.gz: 490cc4f5a7203cc2980a7d4cda061ceff8998f5c75d68f49e15f483fd28bd244793fd5c4d9bae34842e6d29bd1bee94b60e1d43d50d4fe5db408edba04735158
+  data.tar.gz: 3444427c7b794a48e9ee259f66ceadb90793256cefba8483afd53f516c51fd5f3835498a1d9a12b97640e7518119282da42e3d270eea173bd992f85c23615795

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.rvmrc

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in justiz_sync.gemspec
+gemspec
+
+# local development only
+#gem 'opencrx', path: "../opencrx"
+#gem 'justiz', path: "../justiz"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Mike Park
+
+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/README.md

@@ -0,0 +1,29 @@
+# JustizSync
+
+Command line tool to synchronize contact information from justiz gem via the opencrx gem.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'justiz_sync'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install justiz_sync
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/justiz_sync

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'justiz_sync'
+
+JustizSync::Cli.start

data/justiz_sync.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'justiz_sync/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "justiz_sync"
+  spec.version       = JustizSync::VERSION
+  spec.authors       = ["Mike Park"]
+  spec.email         = ["mikep@quake.net"]
+  spec.description   = %q{Reads contact information from justiz gem and saves to LegalEntities using the opencrx gem }
+  spec.summary       = %q{Command line tool to sync contacts from Justiz to openCRX}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "justiz", "~> 0.1.0"
+  spec.add_dependency "opencrx", "~> 0.1.0"
+  spec.add_dependency "thor"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.6"
+  spec.add_development_dependency "awesome_print"
+  spec.add_development_dependency "webmock"
+  spec.add_development_dependency "vcr"
+
+end

data/lib/justiz_sync/cli.rb

@@ -0,0 +1,75 @@
+require 'thor'
+require 'awesome_print'
+require 'justiz'
+
+module JustizSync
+  class Cli < Thor
+    desc "hello NAME", "say hello to NAME"
+    def hello(name)
+      puts "Hello #{name}"
+    end
+
+    option :user, required: true, default: 'guest'
+    option :password, required: true, default: 'guest'
+    option :url, required: true, default: 'http://localhost:8080'
+    option :state
+    option :verbose
+    desc 'sync', 'sync all records from justiz to opencrx'
+    def sync
+      transfer = Transfer.new(options)
+      if (state = options['state'])
+        transfer.sync_state(state)
+      else
+        transfer.sync
+      end
+    end
+  end
+
+  class Transfer
+    attr_reader :options
+    def initialize(options)
+      @options = options
+      STDOUT.sync = true
+      open_connection
+    end
+
+    def sync
+      states = scraper.states
+      total = 0
+      states.keys.each do |state|
+        total += sync_state(state)
+      end
+      puts "Total #{total} synchronized"
+    end
+
+    def sync_state(state)
+      courts = scraper.contacts_for(state)
+      puts "Syncing #{state} #{courts.length} courts"
+      sync_courts(courts)
+      courts.length
+    end
+
+    def sync_courts(courts)
+      courts.each_with_index do |court, index|
+        OpencrxCourt.sync(court)
+        puts if verbose && ((index+1) % 20 == 0)
+        putc('.') if verbose
+      end
+      puts if verbose
+    end
+
+    private
+
+    def verbose
+      options.has_key?('verbose')
+    end
+
+    def open_connection
+      Opencrx::connect(options['url'], options['user'], options['password'])
+    end
+
+    def scraper
+      @scraper ||= Justiz::Scraper::Courts.new
+    end
+  end
+end

data/lib/justiz_sync/opencrx_court.rb

@@ -0,0 +1,126 @@
+require 'opencrx'
+
+module JustizSync
+
+  class OpencrxCourt
+    attr_reader :court
+
+    class << self
+
+      def sync(justiz_court)
+        OpencrxCourt.new(justiz_court).sync
+      end
+
+      def find(id)
+        query = id_to_query(id)
+        Opencrx::Model::LegalEntity.query(query).first
+      end
+
+      # court.id is stored in openCRX userString1
+      def id_to_query(id)
+        {query: "thereExistsUserString1().equalTo(\"#{id}\")"}
+      end
+    end
+
+
+    def initialize(court)
+      @court = court
+    end
+
+    def sync
+      entity.name = court.court
+      entity.aliasName = court.justiz_id
+      entity.save
+
+      court_address = court.location_address
+      process_address(Opencrx::Model::PostalAddress, usage(:visitor), court_address.city.blank?) do |address|
+        address.postalStreet = court_address.street
+        address.postalCode = court_address.plz
+        address.postalCity = court_address.city
+        address.postalCountry = country(:de)
+      end
+
+      court_address = court.post_address
+      process_address(Opencrx::Model::PostalAddress, usage(:business), court_address.city.blank?) do |address|
+        address.postalStreet = court_address.street
+        address.postalCode = court_address.plz
+        address.postalCity = court_address.city
+        address.postalCountry = country(:de)
+      end
+
+      process_address(Opencrx::Model::PhoneNumber, usage(:business), court.phone.blank?) do |address|
+        address.phoneNumberFull = court.phone
+        address.automaticParsing = true
+      end
+
+      process_address(Opencrx::Model::PhoneNumber, usage(:fax), court.fax.blank?) do |address|
+        address.phoneNumberFull = court.fax
+        address.automaticParsing = true
+      end
+
+      process_address(Opencrx::Model::EMailAddress, usage(:business), court.email.blank?) do |address|
+        address.emailAddress = court.email
+      end
+
+      process_address(Opencrx::Model::WebAddress, usage(:business), court.url.blank?) do |address|
+        address.webUrl = court.url
+      end
+    end
+
+    def addresses
+      @addresses ||= entity.query(:address, self.class.id_to_query(court.id))
+    end
+
+    def entity
+      @entity ||= find_entity || create_entity
+    end
+
+    private
+
+    def process_address(klass, usage, destroy, &block)
+      address = find_address(klass, usage)
+      if destroy
+        address.destroy if address
+        return
+      end
+      address ||= create_address(klass, usage)
+      update_address(address, &block)
+    end
+
+    def update_address(address, &block)
+      original_attrs = address.attributes.dup
+      address.isMain = true
+      yield address
+      address.save if address.attributes != original_attrs
+    end
+
+    def find_address(klass, usage)
+      addresses.find do |address|
+        address.usage.include?(usage.to_s) && address.class == klass
+      end
+    end
+
+    def create_address(klass, usage)
+      address = klass.new(usage: usage, userString1: court.id)
+      address.assign_to(entity)
+      address
+    end
+
+    def usage(name)
+      Opencrx::Model::Address::USAGE[name]
+    end
+
+    def country(name)
+      Opencrx::Model::PostalAddress::COUNTRY[name]
+    end
+
+    def find_entity
+      self.class.find(court.id)
+    end
+
+    def create_entity
+      Opencrx::Model::LegalEntity.new(name: court.court, userString1: court.id).save
+    end
+
+  end
+end

data/lib/justiz_sync/version.rb

@@ -0,0 +1,3 @@
+module JustizSync
+  VERSION = "0.1.0"
+end

data/lib/justiz_sync.rb

@@ -0,0 +1,6 @@
+require "justiz_sync/version"
+require 'justiz_sync/opencrx_court'
+require 'justiz_sync/cli'
+
+module JustizSync
+end

data/spec/cli_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe JustizSync::Cli do
+  let(:vcr_options) { {record: :new_episodes, match_requests_on: [:method, :path, :query]} }
+
+  it "syncs all records" do
+    VCR.use_cassette('cli/sync', vcr_options) do
+      JustizSync::Cli.start(%w(sync --verbose  --state=BRD))
+    end
+  end
+end

data/spec/opencrx_court_spec.rb

@@ -0,0 +1,75 @@
+require_relative "spec_helper"
+
+describe JustizSync::OpencrxCourt do
+  before do
+    Opencrx::connect("http://localhost:8080", "guest", "guest")
+  end
+
+  context "sync" do
+    let(:court) { OpenStruct.new(court: 'Staatsanwaltschaft Düsseldorf',
+                                 location_address: OpenStruct.new(
+                                     street: 'Fritz-Roeber-Straße 2', plz: '40213', city: 'Düsseldorf'),
+                                 post_address: OpenStruct.new(
+                                     street: 'P.O.Box 123', plz: '40999', city: 'Düsseldorf - Post'),
+                                 phone: '0211 6025 0',
+                                 fax: '0211 6025 2929',
+                                 justiz_id: 'R1100S',
+                                 url: 'http://www.sta-duesseldorf.nrw.de',
+                                 email: 'poststelle@sta-duesseldorf.nrw.de',
+                                 id: 'Staatsanwaltschaft Düsseldorf/poststelle@sta-duesseldorf.nrw.de'
+    ) }
+
+    let(:vcr_options) { {match_requests_on: [:method, :path, :query, :body]} }
+
+    def find_attribute(addresses, name)
+      addresses.map do |address|
+        address.attribute(name)
+      end.compact
+    end
+
+    def match_court(court, crx)
+      #ap crx.compact
+      #ap crx.addresses.map(&:compact)
+
+      expect(crx.name).to eq(court.court)
+      expect(crx.aliasName).to eq(court.justiz_id)
+      expect(crx.attribute(:userString1)).to eq(court.id)
+
+      addresses = crx.addresses
+
+      expect(find_attribute(addresses, :phoneNumberFull)).to include(court.phone, court.fax)
+      expect(find_attribute(addresses, :postalCode)).to include(court.post_address.plz, court.location_address.plz)
+      expect(find_attribute(addresses, :webUrl)).to eq([court.url])
+      expect(find_attribute(addresses, :emailAddress)).to eq([court.email])
+    end
+
+    it "should create a court" do
+      VCR.use_cassette('create', vcr_options) do
+        JustizSync::OpencrxCourt.sync(court)
+        crx = JustizSync::OpencrxCourt.find(court.id)
+        match_court(court, crx)
+      end
+    end
+
+    it "should find court" do
+      VCR.use_cassette('find', vcr_options) do
+        crx = JustizSync::OpencrxCourt.find(court.id)
+        match_court(court, crx)
+      end
+    end
+
+    it "should update a court" do
+      VCR.use_cassette('update', vcr_options) do
+        court.court += ' Update'
+        court.post_address.plz += ' Update'
+        court.url += ' Update
+'
+        JustizSync::OpencrxCourt.sync(court)
+        crx = JustizSync::OpencrxCourt.find(court.id)
+
+        expect(court.court).to match(/Update/)
+        match_court(court, crx)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'rspec'
+require 'justiz_sync'
+require 'awesome_print'
+require 'vcr'
+
+VCR.configure do |c|
+  c.cassette_library_dir = 'spec/vcr'
+  c.hook_into :webmock
+end