medidata 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 12a82b143cd97a12a83f592971730feca9678a498aceef53671a919f6f3a6413
+  data.tar.gz: f4dadff58258bed1a7f6cb9f16dcd0af6a2ee8aae08a698a6acdec048570024f
+SHA512:
+  metadata.gz: b9af6ed6ceb4d866e0b806c6686bf40ff35155964c0f24871bdbfbfa5eab2eab65e55b11a5ebd6295fbd888afc7ffa49ed2ab5791307e8b55da6b28fa94156f0
+  data.tar.gz: 84bb1fc78121f31c1b237f939dcf0f817c84153968492cc8f31748e86463f65f80976539334ecbab9fb7d2208a255602ccf1036027bfb0a2a3d6108c741b8dc8

data/lib/medidata.rb

@@ -0,0 +1,3 @@
+module Medidata
+  require 'medidata/api'
+end

data/lib/medidata/api.rb

@@ -0,0 +1,10 @@
+module Medidata::API
+  require 'medidata/api/error'
+  require 'medidata/api/http'
+  require 'medidata/api/type'
+  require 'medidata/api/upload'
+  require 'medidata/api/download'
+  require 'medidata/api/participant'
+  require 'medidata/api/notification'
+  require 'medidata/api/client'
+end

data/lib/medidata/api/client.rb

@@ -0,0 +1,198 @@
+module Medidata::API
+  require 'json'
+  require "base64"
+
+  require_relative "error"
+  require_relative "http"
+
+  require_relative "upload"
+  require_relative "participant"
+  require_relative "notification"
+
+  class Client
+    # * *Args*    :
+    #   - +host+ -> REST API client
+    #   - +lang+ -> Preferred language for error messages
+    def initialize(host:, path_prefix: '', lang: 'de')
+      @host = host
+      @lang = lang
+      rest = REST.new(
+        host: host,
+        url_path: [path_prefix],
+        request_headers: {
+          "Accept": "application/json",
+          "Accept-Language": lang,
+          "DenteoSecret": "yes_it's_us"
+        },
+      )
+
+      @rest = rest
+    end
+
+    # Set credentials for this Client's instance
+    #
+    # * *Args*    :
+    #   - +id+ -> Medidata client ID
+    #   - +username+ -> Username
+    #   - +password+ -> password
+    def auth(id, username, password)
+      @rest.update_headers({
+        "X-CLIENT-ID": id,
+        "Authorization": "Basic " + Base64.encode64(username + ":" + password).strip
+      })
+    end
+
+    # * *Args* :
+    #   - +limit+ -> The total number of participants allowed
+    #   - +offset+ -> Pagination offset
+    #   - +query+ -> ParticipantsQuery object (optional)
+    def participants(limit: 100, offset: 0, query: nil)
+      qs = {
+        "limit": limit,
+        "offset": offset
+      }
+      if query
+        qs["lawtype"] = query.lawType if query.lawType
+        qs["name"] = query.name if query.name
+        qs["glnparticipant"] = query.glnParticipant if query.glnParticipant
+      end
+
+      params = {
+        "query_params": qs
+      }
+      res = @rest.ela.participants.get(params)
+      case res.status_code
+      when 200 then
+        body = res.parsed_body
+        raise "Invalid participants response body" unless body.kind_of?(Array)
+        body.map { |row| Medidata::API::Participant.new(row) }
+      when 400 then
+        raise BadRequestError.new("bad request")
+      when 401 then
+        raise UnauthenticatedError.new("authentication required to load participants")
+      when 403 then
+        raise PermissionError.new("wrong credentials to load participants")
+      else
+        raise "Error fetching Medidata participants <#{res.status_code}>"
+      end
+    end
+
+    # Upload a document to Medidata
+    #
+    # * *Args* :
+    #   - +file+ -> File to upload (e.g. Invoice XML)
+    #   - +info+ -> Medidata::API::UploadControlData (optional)
+    def upload(file, info = nil)
+      multipart = Medidata::API::MultipartPost.new
+      multipart.with_binary key: "elauploadstream", value: file
+      multipart.with_text key: "elauploadinfo", value: Medidata::API::UploadControlData.new(info).to_json if info
+
+      bounday = "__MEDI_REST_IN_PEACE__"
+      params = {
+        "request_headers": {
+          "Content-Type": "multipart/form-data; charset=utf-8; boundary=#{bounday}"
+        },
+        "request_body": multipart.build(bounday)
+      }
+      res = @rest.ela.uploads.post(params)
+      case res.status_code
+      when 201 then
+        # Upload created
+        Medidata::API::Upload.new(res.parsed_body)
+      when 400 then
+        raise BadRequestError.new("bad request")
+      when 401 then
+        raise UnauthenticatedError.new("authentication required to upload")
+      when 403 then
+        raise PermissionError.new("wrong credentials to upload")
+      when 409 then
+        # TODO: Extract transmission reference from response
+        raise ConflictError.new("this file has already been uploaded")
+      else
+        raise "Error uploading to Medidata <#{res.status_code}>"
+      end
+    end
+
+    # Check upload status
+    #
+    # * *Args* :
+    #   - +tref+ -> Upload's transmission reference
+    def upload_status(tref)
+      res = @rest.ela.uploads._(tref).status.get
+      case res.status_code
+      when 200 then
+        Medidata::API::Upload.new(res.parsed_body)
+      when 400 then
+        raise BadRequestError.new("bad request")
+      when 401 then
+        raise UnauthenticatedError.new("authentication required to check upload status")
+      when 403 then
+        raise PermissionError.new("wrong credentials to check upload status")
+      when 404 then
+        raise MissingError.new("upload status not found")
+      else
+        raise "Error fetching Medidata upload status <#{res.status_code}>"
+      end
+    end
+
+    # Load pending notifications
+    #
+    # * *Args* :
+    #   - +limit+ -> The total number of notifications allowed
+    #   - +offset+ -> Pagination offset
+    def notifications_pending(limit: 100, offset: 0)
+      params = {
+        "query_params": {
+          "limit": limit,
+          "offset": offset
+        }
+      }
+      res = @rest.ela.notifications.get(params)
+      case res.status_code
+      when 200 then
+        body = res.parsed_body
+        raise "Invalid notifications response body" unless body.kind_of?(Array)
+        body.map { |row| Medidata::API::Notification.new(row) }
+      when 400 then
+        raise BadRequestError.new("bad request")
+      when 401 then
+        raise UnauthenticatedError.new("authentication required to load pending notifications")
+      when 403 then
+        raise PermissionError.new("wrong credentials to load pending notifications")
+      else
+        raise "Error fetching Medidata notifications <#{res.status_code}>"
+      end
+    end
+
+    # Confirm notification receipt
+    #
+    # All notifications received from Medidata are pending by default and
+    # clients have to manually mark them as "read". That should be done
+    # on a regular basis according to Medidata.
+    #
+    # * *Args* :
+    #   - +id+ -> Notification unique identifier
+    def notifications_confirm_receipt(id)
+      params = {
+        "request_body": {
+          "notificationFetched": true
+        }
+      }
+      res = @rest.ela.notifications._(id).status.put(params)
+      case res.status_code
+      when 200, 204 then
+        true
+      when 400 then
+        raise BadRequestError.new("bad request")
+      when 401 then
+        raise UnauthenticatedError.new("authentication required to confirm notification receipt")
+      when 403 then
+        raise PermissionError.new("wrong credentials to confirm notification receipt")
+      when 404 then
+        raise MissingError.new("notification not found")
+      else
+        raise "Error updating notification status <#{res.status_code}>"
+      end
+    end
+  end
+end

data/lib/medidata/api/download.rb

@@ -0,0 +1,29 @@
+module Medidata::API
+  require_relative "type"
+
+  # A Download is available when an invoice has been sent to the insurance company,
+  # but the content check does not go through there and an invoice response
+  # (General Invoice Response) is returned.
+  # These invoice responses then arrive on the MD client and have to be downloaded
+  # and confirmed by the customer's Denteo application using ela / downloads.
+  class Download < Dry::Struct
+    # Reference to the document. This is generated by the MediData client.
+    attribute :transmissionReference, Types::Strict::String
+    # Reference to the document
+    attribute :documentReference, Types::Strict::String
+    # Reference to the business case
+    attribute :correlationReference, Types::Strict::String
+    # Sender identification
+    attribute :senderGln, Types::Strict::String
+    # MIME document type
+    attribute :docType, Types::Strict::String
+    # Length of the document in bytes
+    attribute :fileSize, Types::Strict::Integer
+    # TEST or PRODUCTION
+    attribute :mode, Types::Strict::String
+    # Document status
+    attribute :status, Types::Strict::String
+    # Date document was delivered
+    attribute :created, Types::JSON::DateTime
+  end
+end

data/lib/medidata/api/error.rb

@@ -0,0 +1,13 @@
+module Medidata::API
+  class MissingError < StandardError
+  end
+  class BadRequestError < StandardError
+  end
+  class PermissionError < StandardError
+  end
+  class UnauthenticatedError < StandardError
+  end
+  class ConflictError < StandardError
+    # TODO: Add resource
+  end
+end

data/lib/medidata/api/http.rb

@@ -0,0 +1,363 @@
+module Medidata::API
+  require 'json'
+  require 'net/http'
+  require 'net/https'
+  require "uri"
+
+  # Holds the response from an API call.
+  class Response
+    # Provide useful functionality around API rate limiting.
+    class Ratelimit
+      attr_reader :limit, :remaining, :reset
+
+      # * *Args*    :
+      #   - +limit+ -> The total number of requests allowed within a rate limit window
+      #   - +remaining+ -> The number of requests that have been processed within this current rate limit window
+      #   - +reset+ -> The time (in seconds since Unix Epoch) when the rate limit will reset
+      def initialize(limit, remaining, reset)
+        @limit = limit.to_i
+        @remaining = remaining.to_i
+        @reset = Time.at reset.to_i
+      end
+
+      def exceeded?
+        remaining <= 0
+      end
+
+      # * *Returns* :
+      #   - The number of requests that have been used out of this
+      #     rate limit window
+      def used
+        limit - remaining
+      end
+
+      # Sleep until the reset time arrives. If given a block, it will
+      # be called after sleeping is finished.
+      #
+      # * *Returns* :
+      #   - The amount of time (in seconds) that the rate limit slept
+      #     for.
+      def wait!
+        now = Time.now.utc.to_i
+        duration = (reset.to_i - now) + 1
+
+        sleep duration if duration >= 0
+
+        yield if block_given?
+
+        duration
+      end
+    end
+
+    # * *Args*    :
+    #   - +response+ -> A NET::HTTP response object
+    #
+    attr_reader :status_code, :body, :headers
+
+    def initialize(response)
+      @status_code = response.code.to_i
+      @body = response.body
+      @headers = response.to_hash
+    end
+
+    # Returns the body as a hash
+    #
+    def parsed_body
+      @parsed_body ||= JSON.parse(@body, symbolize_names: true)
+    end
+
+    def ratelimit
+      return @ratelimit unless @ratelimit.nil?
+
+      limit = headers['X-RateLimit-Limit']
+      remaining = headers['X-RateLimit-Remaining']
+      reset = headers['X-RateLimit-Reset']
+
+      # Guard against possibility that one (or probably, all) of the
+      # needed headers were not returned.
+      @ratelimit = Ratelimit.new(limit, remaining, reset) if limit && remaining && reset
+
+      @ratelimit
+    end
+  end
+
+  # A simple REST client.
+  class REST
+    attr_reader :host, :request_headers, :url_path, :request, :http
+    # * *Args*    :
+    #   - +host+ -> Base URL for the api. (e.g. https://api.sendgrid.com)
+    #   - +request_headers+ -> A hash of the headers you want applied on
+    #                          all calls
+    #                  (e.g. client._("/v3"))
+    #   - +url_path+ -> A list of the url path segments
+    #   - +proxy_options+ -> A hash of proxy settings.
+    #                        (e.g. { host: '127.0.0.1', port: 8080 })
+    #
+    def initialize(host: nil, request_headers: nil, url_path: nil, http_options: {}, proxy_options: {}) # rubocop:disable Metrics/ParameterLists
+      @host = host
+      @request_headers = request_headers || {}
+      @url_path = url_path || []
+      @methods = %w[delete get patch post put]
+      @query_params = nil
+      @request_body = nil
+      @http_options = http_options
+      @proxy_options = proxy_options
+    end
+
+    # Update the headers for the request
+    #
+    # * *Args*    :
+    #   - +request_headers+ -> Hash of request header key/values
+    #
+    def update_headers(request_headers)
+      @request_headers.merge!(request_headers)
+    end
+
+    # Build the final request headers
+    #
+    # * *Args*    :
+    #   - +request+ -> HTTP::NET request object
+    # * *Returns* :
+    #   - HTTP::NET request object
+    #
+    def build_request_headers(request)
+      @request_headers.each do |key, value|
+        request[key] = value
+      end
+      request
+    end
+
+    # Add query parameters to the url
+    #
+    # * *Args*    :
+    #   - +url+ -> path to endpoint
+    #   - +query_params+ -> hash of query parameters
+    # * *Returns* :
+    #   - The url string with the query parameters appended
+    #
+    def build_query_params(url, query_params)
+      params = URI.encode_www_form(query_params)
+      url.concat("?#{params}")
+    end
+
+    # Set the query params, request headers and request body
+    #
+    # * *Args*    :
+    #   - +args+ -> array of args obtained from method_missing
+    #
+    def build_args(args)
+      args.each do |arg|
+        arg.each do |key, value|
+          case key.to_s
+          when 'query_params'
+            @query_params = value
+          when 'request_headers'
+            update_headers(value)
+          when 'request_body'
+            @request_body = value
+          end
+        end
+      end
+    end
+
+    # Build the final url
+    #
+    # * *Args*    :
+    #   - +query_params+ -> A hash of query parameters
+    # * *Returns* :
+    #   - The final url string
+    #
+    def build_url(query_params: nil)
+      url = @url_path.join('/')
+      url = build_query_params(url, query_params) if query_params
+      URI.parse([@host, url].join('/'))
+    end
+
+    # Build the API request for HTTP::NET
+    #
+    # * *Args*    :
+    #   - +name+ -> method name, received from method_missing
+    #   - +args+ -> args passed to the method
+    # * *Returns* :
+    #   - A Response object from make_request
+    #
+    def build_request(name, args)
+      build_args(args) if args
+      # build the request & http object
+      build_http_request(name)
+      # set the content type & request body
+      build_request_body(name)
+      make_request(@http, @request)
+    end
+
+    # Make the API call and return the response. This is separated into
+    # it's own function, so we can mock it easily for testing.
+    #
+    # * *Args*    :
+    #   - +http+ -> NET:HTTP request object
+    #   - +request+ -> NET::HTTP request object
+    # * *Returns* :
+    #   - Response object
+    #
+    def make_request(http, request)
+      response = http.request(request)
+      Response.new(response)
+    end
+
+    # Build HTTP request object
+    #
+    # * *Returns* :
+    #   - Request object
+    def build_http(host, port)
+      params = [host, port]
+      params += @proxy_options.values_at(:host, :port, :user, :pass) unless @proxy_options.empty?
+      http = add_ssl(Net::HTTP.new(*params))
+      http = add_http_options(http) unless @http_options.empty?
+      http
+    end
+
+    # Allow for https calls
+    #
+    # * *Args*    :
+    #   - +http+ -> HTTP::NET object
+    # * *Returns* :
+    #   - HTTP::NET object
+    #
+    def add_ssl(http)
+      if host.start_with?('https')
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+      end
+      http
+    end
+
+    # Add others http options to http object
+    #
+    # * *Args*    :
+    #   - +http+ -> HTTP::NET object
+    # * *Returns* :
+    #   - HTTP::NET object
+    #
+    def add_http_options(http)
+      @http_options.each do |attribute, value|
+        http.send("#{attribute}=", value)
+      end
+      http
+    end
+
+    # Add variable values to the url.
+    # (e.g. /your/api/{variable_value}/call)
+    # Another example: if you have a ruby reserved word, such as true,
+    # in your url, you must use this method.
+    #
+    # * *Args*    :
+    #   - +name+ -> Name of the url segment
+    # * *Returns* :
+    #   - REST object
+    #
+    def _(name = nil)
+      url_path = name ? @url_path + [name] : @url_path
+      REST.new(
+        host: @host,
+        request_headers: @request_headers,
+        url_path: url_path,
+        http_options: @http_options
+      )
+    end
+
+    # Dynamically add segments to the url, then call a method.
+    # (e.g. client.name.name.get())
+    #
+    # * *Args*    :
+    #   - The args are automatically passed in
+    # * *Returns* :
+    #   - REST object or Response object
+    #
+    # rubocop:disable Style/MethodMissingSuper
+    # rubocop:disable Style/MissingRespondToMissing
+    def method_missing(name, *args, &_block)
+      # We have reached the end of the method chain, make the API call
+      return build_request(name, args) if @methods.include?(name.to_s)
+
+      # Add a segment to the URL
+      _(name)
+    end
+
+    private
+
+    def build_http_request(http_method)
+      uri = build_url(query_params: @query_params)
+      net_http = Kernel.const_get('Net::HTTP::' + http_method.to_s.capitalize)
+
+      @http = build_http(uri.host, uri.port)
+      @request = build_request_headers(net_http.new(uri.request_uri))
+    end
+
+    def build_request_body(http_method)
+      if @request_body && is_json_request? && [Hash, Array].include?(@request_body.class)
+        @request.body = @request_body.to_json
+        @request['Content-Type'] = 'application/json'
+      elsif !@request_body && http_method.to_s != 'get'
+        @request['Content-Type'] = ''
+      else
+        @request['Content-Type'] = @request_headers[:'Content-Type']
+        @request.body = @request_body
+      end
+    end
+
+    def is_json_request?
+      !@request_headers.key?(:'Content-Type') || @request_headers[:'Content-Type'] == 'application/json'
+    end
+    # rubocop:enable Style/MethodMissingSuper
+    # rubocop:enable Style/MissingRespondToMissing
+  end
+
+  class MultipartPost
+    EOL = "\r\n"
+
+    def initialize
+      @params = Array.new
+    end
+
+    def with_text(key:, value:)
+      @params << multipart_text(key, value)
+    end
+
+    def with_binary(key:, value:)
+      @params << multipart_binary(key, value)
+    end
+
+    def with_file(key:, value:, filename:, mime_type:)
+      @params << multipart_file(key, value, filename, mime_type)
+    end
+
+    def build(bounday)
+      body = @params.map{|p| "--#{bounday}#{EOL}" << p}.join ""
+      body << "#{EOL}--#{bounday}--#{EOL}"
+    end
+
+    private
+
+    def multipart_text(key, value)
+      "Content-Disposition: form-data; name=\"#{key}\"" <<
+        EOL <<
+        EOL <<
+        "#{value}" << EOL
+    end
+
+    def multipart_file(key, value, filename, mime_type)
+      "Content-Disposition: form-data; name=\"#{key}\"; filename=\"#{filename}\"#{EOL}" <<
+        "Content-Type: #{mime_type}#{EOL}" <<
+        EOL <<
+        "#{value}" << EOL
+    end
+
+    def multipart_binary(key, value)
+      "Content-Disposition: form-data; name=\"#{key}\"#{EOL}" <<
+        "Content-Transfer-Encoding: binary#{EOL}" <<
+        "Content-Type: application/octet-stream#{EOL}" <<
+        EOL <<
+        "#{value}" << EOL
+    end
+  end
+end

data/lib/medidata/api/notification.rb

@@ -0,0 +1,39 @@
+module Medidata::API
+  require_relative "type"
+
+  # A Notification is generated when an upload results in the status «ERROR»,
+  # e.g. the schema check on the MD client detects an error.
+  #
+  # The status ERROR indicates that there was an error during the transmission
+  # and the recipient did not receive the file.
+  # In the associated notification of this ERROR, the customer receives more
+  # detailed information on the error code, cause and possible remedial measures.
+  class Notification < Dry::Struct
+    # ID is a unique identifier for notification
+    attribute :id, Types::Strict::Integer.optional
+    # Subject of the notification (in three languages)
+    attribute :subject, Types::Strict::Hash
+    # The content of the notification (in three languages)
+    attribute :message, Types::Strict::Hash
+    # The notification type.
+    attribute :type, Types::Strict::String.optional.default("".freeze)
+    # “true” if the notification has already been marked as red, otherwise “false”.
+    attribute :read, Types::Strict::Bool.default(false)
+    # The notification’s creation date ISO 8601 timestamp
+    attribute :created, Types::JSON::DateTime
+    # The template’s name
+    attribute :template, Types::Strict::String
+    # The notification’s mode
+    attribute :mode, Types::Strict::String
+    # The error code
+    attribute :errorCode, Types::Strict::String
+    # Possible causes (in three languages). Texts are entered by MediData
+    attribute :potentialReasons, Types::Strict::Hash
+    # Possible solutionss (in three languages). Texts are entered by MediData
+    attribute :possibleSolutions, Types::Strict::Hash
+    # Additional parameters for notification
+    attribute :notificationParameters, Types::Strict::Hash
+    # Additional technical information. (can be used for problem analysis.
+    attribute :technicalInformation, Types::Strict::String.optional.default(nil)
+  end
+end

data/lib/medidata/api/participant.rb

@@ -0,0 +1,47 @@
+module Medidata::API
+  require_relative "type"
+
+  class Participant < Dry::Struct
+    # Recipient’s GLN number.
+    # Note: Always the same GLN as with the parameter “glnReceiver”.
+    attribute :glnParticipant, Types::Strict::String
+    # Recipient’s GLN number
+    attribute :glnReceiver, Types::Strict::String
+    # Name of the participant
+    attribute :name, Types::Strict::String
+    # Address (street name + house number)
+    attribute :street, Types::Strict::String
+    # Post code
+    attribute :zipCode, Types::Strict::String
+    # Name of city
+    attribute :town, Types::Strict::String
+    # List of laws supported by the participants
+    attribute :lawTypes, Types::Strict::Array
+    # Number registered with the Swiss Federal Office of Public Health (FOPH)
+    attribute :bagNumber, Types::Strict::Integer.optional
+    # Is the change from TG to TP accepted by the participant. The default is false.
+    attribute :tgTpChange, Types::Strict::Bool
+    # The sending of a document to this participant may result in additional
+    # costs (e.g. printing costs) if additionalCosts is set to true. The default is false.
+    attribute :additionalCosts, Types::Strict::Bool
+    # Maximum document size that the participant can or wants to receive.
+    attribute :maxReceive, Types::Strict::Integer
+    # List of the document MIME types not supported by the participant.
+    # No documents of this type may be sent to the recipient.
+    attribute :notSupported, Types::Strict::Array
+    # Specifies whether the participant can receive and process TG documents.
+    attribute :tgAllowed, Types::Strict::Bool
+  end
+
+  class ParticipantsQuery
+    attr_reader :lawType, :name, :glnParticipant
+
+    def initialize(lawType: "", name: "", glnParticipant: "")
+      @lawType = lawType
+      @name = name
+      @glnParticipant = glnParticipant
+    end
+  end
+
+  # TODO: Add LawType type
+end

data/lib/medidata/api/type.rb

@@ -0,0 +1,8 @@
+module Medidata::API
+  require 'dry-types'
+  require 'dry-struct'
+
+  module Types
+    include Dry.Types()
+  end
+end

data/lib/medidata/api/upload.rb

@@ -0,0 +1,88 @@
+module Medidata::API
+  require_relative "type"
+
+  # Upload: is generally used for sending payloads in XML format, i.e. sending the invoice.
+  class Upload < Dry::Struct
+    # Reference to the document sent
+    attribute :transmissionReference, Types::Strict::String
+    # Date document was delivered
+    attribute :created, Types::JSON::DateTime.optional.default(nil)
+    # Date of last modification
+    attribute :modified, Types::JSON::DateTime.optional.default(nil)
+    # Current status of main delivery.
+    # The status is a summary of all subdeliveries.
+    attribute :status, Types::Strict::String.optional.default("".freeze)
+  end
+
+  class UploadControlData < Dry::Struct
+    # Transmission mode. The “Mode” control parameter must be identical to
+    # the “Mode” attribute in the XML document. Otherwise, an error will be generated.
+    attribute :mode, Types::Strict::String.optional.default(nil)
+    # Dispatch to organisation (no data warehouse).
+    # Overrides the “to” attribute (GLN recipient) in the XML document.
+    #
+    # In the case of “2000000000008” or “0000000000000”, the following applies
+    # • A TP invoice is not delivered to an organisation
+    # • A TG invoice is not delivered to an organisation, but to the TG warehouse.
+    #
+    # An error will be generated with all other differences as compared with
+    # the “to” attribute in XML.
+    attribute :toOrganization, Types::Strict::String.optional.default(nil)
+    # Dispatch to data warehouse (TrustCenter).
+    # Overrides the configured data warehouse in the MediData client.
+    # This must be a TrustCenter that the sender knows. See participant directory.
+    # No dispatch to a data warehouse will be overridden with
+    # value “2000000000008” or “0000000000000”.
+    attribute :toTrustCenter, Types::Strict::String.optional.default(nil)
+    # Dispatch to patients or to their legal representatives (guarantor, debtor).
+    #
+    # If the value is set to “true”, the dispatch will be triggered; if the
+    #  value is set to “false”, dispatch will not take place.
+    # In the case of a Tiers Payant (TP) doc- ument, this value overrides the
+    #  TP patient copy to the guarantors.
+    # In the case of a Tiers Garant (TG) doc- ument, this value overrides the TG
+    #  patient invoice and the reimbursement receipt.
+    attribute :toPatient, Types::Strict::Bool.default(false)
+    # Defines the print language of the document (print layout).
+    # If this parameter is not set, it is read from the document or configuration.
+    attribute :printLanguage, Types::Strict::String.optional.default(nil)
+    # Type of postal dispatch.
+    # If this parameter is not set, it is read from the document or configuration.
+    attribute :postalDelivery, Types::Strict::String.optional.default(nil)
+    # Forces postal delivery to the patient.
+    # “true” forces printing with postal delivery
+    #  (if multiple types of delivery are possible, such as electronic and post- al).
+    # “False” means “no forcing”.
+    #  Application: e.g. a reminder should be sent to the guarantor/debtor by post.
+    attribute :forcePostalToPatient, Types::Strict::Bool.default(false)
+    # Contains a document designation unique to the participant.
+    # The reference data must consist solely of alphanumeric characters
+    # (incl. special characters) and be between min. 1 and max. 100 characters long.
+    attribute :documentReference, Types::Strict::String.optional.default(nil)
+    # Contains a business case number. This number is for all sent and received
+    # documents that belong to the same business case in technical terms.
+    #
+    # In this way, all documents belonging to the same business case can be
+    # clearly summarised. If this is missing, it is generated from the document
+    # content by the MediData client according to the description in the annex.
+    #
+    # The business number case must consist solely of alphanumeric characters
+    # (incl. special characters) and be between min.
+    # 1 and max. 100 characters long.
+    attribute :correlationReference, Types::Strict::String.optional.default(nil)
+
+    def to_json
+      s = {}
+      s[:mode] = mode if mode
+      s[:toOrganization] = toOrganization if toOrganization
+      s[:toTrustCenter] = toTrustCenter if toTrustCenter
+      s[:toPatient] = toPatient if toPatient
+      s[:printLanguage] = printLanguage if printLanguage
+      s[:postalDelivery] = postalDelivery if postalDelivery
+      s[:forcePostalToPatient] = forcePostalToPatient if forcePostalToPatient
+      s[:documentReference] = documentReference if documentReference
+      s[:correlationReference] = correlationReference if correlationReference
+      JSON.generate(s)
+    end
+  end
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: medidata
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Denteo AG
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.5.1
+- !ruby/object:Gem::Dependency
+  name: dry-struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.4.0
+description: Ruby client interacting with Medidata REST API
+email: simon@denteo.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/medidata.rb
+- lib/medidata/api.rb
+- lib/medidata/api/client.rb
+- lib/medidata/api/download.rb
+- lib/medidata/api/error.rb
+- lib/medidata/api/http.rb
+- lib/medidata/api/notification.rb
+- lib/medidata/api/participant.rb
+- lib/medidata/api/type.rb
+- lib/medidata/api/upload.rb
+homepage: https://rubygems.org/gems/medidata
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Ruby client interacting with Medidata REST API
+test_files: []