elibri_watermarking 0.9.12 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6dfeccb31fb16c84d2df681c37df78b70806f7b075380a45059d393774e8811b
-  data.tar.gz: '00569eacecf7a8d1f61e72d0a9bd03984c8a8725f666d7f3513a3c058a8d068f'
+  metadata.gz: 7da8046f7838971cb2018299ea60181556f6a0b77e3a9ae166878db5d3bc32ea
+  data.tar.gz: 18a0c3940cb3f71e90706ed8de498a09432d75b5766b49363ceb609c6d142381
 SHA512:
-  metadata.gz: 3d2874427b18fff2d1b47f3c509bf92973336b9eab6b115c92bb7c4b3e7ac50088c8370c1e6d218a95e2d6343ca408d953787a17b92d972a29a3526c43470788
-  data.tar.gz: 17c627667d83ca72287445758cbf09c53db4afe537993c2dfe1ee682326a25817d5a7384eed0a4ff5184e1960d67536ee057dc279c902a47b98c8cf2969ba0cf
+  metadata.gz: cfac4d93c881d47f52351d03d0ccd097891ed448935861aba6310a96c6b5e988b6c9ca277300a9925b937aae4a9b1c7bd9ba39643eeac888521bff610fe5175d
+  data.tar.gz: 2fd51e451aaae9d5d829071376690b6d316f5501d3982de7f190a4201f7b8f99f04c21d2815fcca4e0af0c71a1e290f6608717661f0ab715581bf96dca14c3e8

data/README.md

@@ -1,101 +1,24 @@
-# Biblioteka Elibri Watermarking
+# Elibri Watermarking
 
-## Opis
+## Description
 
-Biblioteka Elibri Watermarking, dostarczana jest w postaci pliku gema (dostępna na rubygems: https://rubygems.org/gems/elibri_watermarking ).
-Użycie wymaga wcześniejszego kontaktu z serwisem Elibri (kontakt@elibri.com.pl), w celu otrzymania danych dostępowych do API.
+This library implements [Elibri Watermarking API](https://www.elibri.com.pl/doc/watermarking/api) in ruby.
 
-## Zastosowanie
+## Usage
 
-Biblioteka Elibri Watermarking upraszcza operacje wykonywane na API watermarkingu Elibri, abstrahując je do operacji wykonywanych na obiekcie Rubyego.
+First, include `elibri_watermarking` in your Gemgile
 
-## Użycie
+Next, initialise the client: 
 
-Aby użyć biblioteki w aplikacji Ruby on Rails, do pliku Gemfile należy dodać:
-
-```gem 'elibri_watermarking```
-
-aby użyć gema, poza aplikacją rails należy go zainstalować, komendą:
- 
-```gem install elibri_watermarking```
-
-a następnie w konsoli w której chcemy użyć biblioteki wpisujemy: 
-
-```ruby
-require 'rubygems'
-require 'elibri_watermarking'
-```
-
-Następnie musimy zainicjalizować bibliotekę, podając token i secret, otrzymane od Elibri:
 ```ruby
 client = ElibriWatermarking::Client.new('token', 'secret')
 ```
 
-Biblioteka daje nam do dyspozycji parę metod, odpowiadających wywołaniom metod API watermarkingu elibri:
-
-* watermark (przyjmuje parametry: identyfikator [ISBN bez myślników lub record_reference], formaty [zapisana po przecinku lista formatów do watermarkingu - najcześciej "epub,mobi", możliwe wartości:  epub, mobi, pdf, mp3_in_zip], widoczny watermark [tekst widoczny na końcu każdego rozdziału], dopisek [krótki tekst dopisany do tytułu], supplier [numeryczny identyfikator dostawcy pliki], client_symbol [alfanumeryczny identyfikator zapisany przy transakcji], customer_ip [ip klienta końcowego, do celów statystycznych], price [cena zakupu pliku przez klienta końcowego], promotion_id [id promocji w jakiej został zakupiony plik], delivery_form [opcjonalna forma dostarczenia (używane tylko przy audiobooku). Może przyjąć wartości: zip (wtedy audiobook zostanie dostarczony jako plik zip), lub mp3 (wtedy w miarę postępu procesu watermarkowania, pojawiać się będą kolejne pliki w folderze o nazwie równej trans_id, na S3). W przypadku drugiej formy, klient zostanie powiadomiony o zakończeniu procesu dopiero gdy wszystkie pliki zostaną zwatermarkowane (wtedy również w folderze S3 pojawi się plik done). Jeśli sklep chce pobierać pliki mp3 w miarę postępu watermarkowania, jest zobowiązany do sprawdzania ich obecności na s3, zanim zostanie poinformowany o zakończeniu transakcji. W przypadku używania typu dostarczenia=mp3, audiobook musi być jedynym formatem, który jest żądany w danej transakcji] - zwraca identyfikator transakcji, który klient zobowiązany jest zapisać i przechowywać) - wywołuje żądanie watermarku na podanym produkcie, w podanych formatach
-* deliver (przyjmuje jeden parametr: identifykator transacji [otrzymany od watermark]) - wywołuje żądanie dostarczenia zwatermarkowanego pliku do bucketu klienta na s3
-* watermark_and_deliver (przyjmuje parametry identyczne jak watermark, zwraca identyfikator transacji, który klient zobowiązany jest zapisać i przechowywać) - wywołuje watermarkowanie pliku, a następnie żąda jego dostarczenia do bucketu klienta na s3
-* retry (przyjmuje jako parametr identyfikator transakcji, zwraca identyfikator nowej transakcji i opcjonalnie delivery_form [opcjonalna forma dostarczenia (używane tylko przy audiobooku), analogicznie jak przy watermark]) - wywołuje żądanie ponowienia watermarkingu pliku, który został już ściągnięty (uwaga - sklep jest zobowiązany do przetrzymywanie zwatermarkowanego pliku przynajmniej przez 7 dni, dopiero po tym czasie możliwe jest wywołanie retry). Watermarking wykonywany jest z identycznymi parametrami, jak poprzedni. Klient zobowiązany jest zapisać i przechowywać nowy identyfikator transakcji. Po komendzie retry, niezbędne jest wywołanie komendy deliver w celu dostarczeni pliku do bucketu s3. Uwaga! Każdą transakcję retryować mozna tylko raz - w przypadku kolejnego żądania retry, konieczne jest podanie identyfikatora transakcji otrzymanego od poprzedniej komendy retry.
-* available_files - zwraca listę dostępnych do watermarkingu przez klienta plików. Pliki są zwracane w postaci tablicy hashów, postaci:
-```ruby
-[
-  {
-    :record_reference => 'a'
-    :publisher_name => 'b'
-    :publisher_id => 1
-    :isbn => '1234'
-    :title => 'Tytuł',
-    :formats => ["epub", "mobi"]
-    :available_date => "data od kiedy plik jest dostępny - jeśli pole nie występuje, znaczy to, że plik jest dostępny"
-    :suppliers => [1, 2, 3] #tablica zawierająca identyfikatora dostawców, mogących dostarczyć plik dla danego klienta
-    :available_until => "data do kiedy plik jest dostępny - jeśli nie występuje, znaczy to, że plik nie jest wygasający"
-  }
-]
-```
-* soon_available_files - zwraca listę wkrótce dostępnych do watermarkingu przez klienta plików. Format analogiczny jak w metodzie available_files.
-* soon_unavailable_files - zwraca listę plików dostępnych do watermarkingu, które wkrótce wygasną (przestaną być dostępne). Format analogiczny jak w metodzie available_files.
-* check_suppliers (przyjmuje jeden parametr: identyfikator [ISBN bez myślników lub record_reference]) - zwraca listę dostawców danego pliku, w postaci tablicy zawierającej numeryczne identyfikatory dostawców
-* get_supplier (przyjmuje jeden parametr: numeryczny identyfikator dostawcy w systemie eLibri) - zwraca nazwę dostawcy o podanym identyfikatorze
-* new_complaint (przyjmuje dwa parametry: identyfikator tranksacji do zareklamowania i powód reklamacji) - zgłasza nową reklamację do transakcji w systemie eLibri
-
-## Błędy
-
-Wywołanie poszczególnych metod może spowodować wywołanie jednego z następujących wyjątków:
-
-* ParametersError - do serwera zostały wysłane złe parametry
-* AuthenticationError - podany został zły token lub zły sig
-* AuthorizationError - podany klient nie ma dostępu żądanego produktu, lub ten produkt nie istnieje, lub produkt nie posiada żądanego formatu
-* ServerException - wystąpił wewnętrzny błąd serwera elibri
-* RequestExpired - podany został zbyt stary request (request ważny jest 60 sekund)
-
-Wszystkie te wyjątki, dziedziczą po klasie ElibriException, a także zawierają w treści opis błędu otrzymanego od API.
-
-## Odebranie pliku
-
-Po wywołaniu komendy deliver, plik zostaje załadowany do bucketu s3 (dane dostępowego do niego, otrzymacie Państwo podczas zakładania konta API). Sklep zobowiązany jest ściągnąć zwatermarkowany plik z bucketu s3 i przechowywać go po swojej stronie przez minimum 7 dni.
-Plik zawsze będzie nazwany zgodnie z następującą konwencją:
-
-```
-trans_id.format
-```
-
-gdzie trans_id to identyfikator transakcji w systemie elibri (otrzymany podczas zlecania watermarkingu), a format to jeden z: epub, mobi.
-
-
-Przykładowy kod umożliwiający odczytanie i zapisanie na własnym serwerze zwatermarkowanego pliku z bucketu s3:
-```ruby
-require 'rubygems'
-require 'aws-sdk'
-
-s3 = AWS::S3.new(:access_key_id => 'amazon access key', :secret_access_key => 'amazon secret key')
-File.open('ścieżka do pliku docelowego na serwerze', 'w') do |f|
-  f.puts s3.buckets['nazwa bucketu otrzymana przy rejestracji'].objects["identyfikator transacji.żądany format"].read
-end
-```
-
-## Powiadomienie o dostępności pliku
-
-Po wykonaniu polecenia deliver, plik zostanie umieszczony w buckecie s3. Sklep zostanie powiadomiony o tym fakcie, za pomocą requestu na podany przez niego endpoint.
+Available methods:
 
-Request jest typu post, zawiera w swojej treści identyfikator ukończonej transakcji - po jego otrzymaniu sklep powinien odebrać plik z bucketu s3 i zapisać go u siebie na serwerze.
+* watermark - registers transaction
+* deliver - commits transaction
+* available_files - a list of all available products
+* soon_available_files - a list of soon available products
+* soon_unavailable_files - a list of soon expiring products
+* new_complaint - files a complains or cancelation

data/lib/elibri_watermarking/client.rb

@@ -11,104 +11,75 @@ require 'json'
 module ElibriWatermarking
   class Client
 
-    attr_accessor :token, :secret, :logger, :servers
+    attr_accessor :token, :secret, :logger, :server
 
-    def initialize(token, secret, servers = nil)
+    def initialize(token, secret, server = nil)
       self.token = token
       self.secret = secret
-      self.servers = servers
+      self.server = server || "https://www.elibri.com.pl"
     end
 
-    def watermark(ident, formats, visible_watermark, title_postfix, customer_ip, client_symbol = nil, supplier = nil,
-                  delivery_form = nil, price = nil, promotion_id = nil, low_priority = false)
+    def watermark(ident, formats:, visible_watermark:, client_symbol: nil, price: nil, promotion_id: nil, low_priority: false)
       if ident =~ /^[0-9]+$/ && ident.size == 13
         ident_type = 'isbn'
       else
         ident_type = 'record_reference'
       end
-      raise WrongFormats.new if formats.is_a?(String) && !formats =~ /^(epub|mobi|pdf|mp3_in_zip|,)+$/
+      raise WrongFormats.new if formats.is_a?(String) && !(formats =~ /^(epub|mobi|pdf|mp3_in_zip|mp3_in_lpf|,)+$/)
       raise WrongFormats.new if formats.is_a?(Array) && ((formats - ['epub','mobi','pdf','mp3_in_zip']) != [] || (formats & ['epub','mobi','pdf','mp3_in_zip']).count < 1)
       formats = formats.join(",") if formats.is_a?(Array)
-      raise ParametersError.new if delivery_form && formats != 'mp3_in_zip'
-      raise ParametersError.new if delivery_form && (delivery_form != 'mp3' && delivery_form != 'zip')
-      data = {ident_type => ident, 'formats' => formats, 'visible_watermark' => visible_watermark,
-              'title_postfix' => title_postfix, 'client_symbol' => client_symbol, 'delivery_form' => delivery_form}
-      data.merge!(:supplier => supplier) if supplier
-      data.merge!(:customer_ip => customer_ip) if customer_ip
-      data.merge!(:price => price) if price
-      data.merge!(:promotion_id => promotion_id) if promotion_id
-      data.merge!(:low_priority => low_priority) if low_priority
-      try_with_different_servers('watermark') do |uri|
+      data = { ident_type => ident, formats: formats, visible_watermark: visible_watermark }
+      data.merge!(client_symbol: client_symbol) if client_symbol
+      data.merge!(price: price) if price
+      data.merge!(promotion_id: promotion_id) if promotion_id
+      data.merge!(low_priority: low_priority) if low_priority
+      construct_url('watermark') do |uri|
         return get_response_from_server(uri, data, Net::HTTP::Post)
       end
     end
 
-    def deliver(trans_id, low_priority = false)
-      try_with_different_servers('deliver') do |uri|
-        data = {'trans_id' =>  trans_id}
-        data.merge!(:low_priority => low_priority) if low_priority
+    def deliver(trans_id, low_priority: false)
+      construct_url('deliver') do |uri|
+        data = { trans_id: trans_id }
+        data.merge!(low_priority: low_priority) if low_priority
         return get_response_from_server(uri, data, Net::HTTP::Post)
       end
     end
 
-    def retry(trans_id, delivery_form = nil, low_priority = false)
-      try_with_different_servers('retry') do |uri|
-        data = {'trans_id' =>  trans_id, 'delivery_form' => delivery_form}
+    def retry(trans_id, low_priority: false)
+      construct_url('retry') do |uri|
+        data = { trans_id: trans_id, delivery_form: delivery_form}
         data.merge!(:low_priority => low_priority) if low_priority
         return get_response_from_server(uri, data, Net::HTTP::Post)
       end
     end
 
     def available_files
-      try_with_different_servers('available_files.json') do |uri|
+      construct_url('available_files.json') do |uri|
         return JSON.parse(get_response_from_server(uri, {}, Net::HTTP::Get))
       end
     end
 
     def soon_available_files
-      try_with_different_servers('soon_available_files.json') do |uri|
+      construct_url('soon_available_files.json') do |uri|
         return JSON.parse(get_response_from_server(uri, {}, Net::HTTP::Get))
       end
     end
 
     def soon_unavailable_files
-      try_with_different_servers('soon_unavailable_files.json') do |uri|
+      construct_url('soon_unavailable_files.json') do |uri|
         return JSON.parse(get_response_from_server(uri, {}, Net::HTTP::Get))
       end
     end
 
-    def check_suppliers(ident)
-      ident =~ /^[0-9]+$/ ? ident_type = 'isbn' : ident_type = 'record_reference'
-      try_with_different_servers('check_suppliers') do |uri|
-        return get_response_from_server(uri, { ident_type => ident}, Net::HTTP::Get).split(",").map { |x| x.to_i }
-      end
-    end
-
-    def get_supplier(id)
-      get_response_from_server(construct_main_server_url('/watermarking/get_supplier'), {:id => id}, Net::HTTP::Get)
-      #to chyba moze byc tylko z glownego serwera?
-    end
-
-    def check_api
-      try_with_different_servers('ver') do |uri|
-        return get_response_from_server(uri, {}, Net::HTTP::Get)
-      end
-    end
-
     def new_complaint(trans_id, reason)
-      get_response_from_server(construct_main_server_url('/api_complaints'), {:trans_id => trans_id, :reason => reason}, Net::HTTP::Post)
+      construct_url('/api_complaints') do |uri|
+        return get_response_from_server(uri, {:trans_id => trans_id, :reason => reason}, Net::HTTP::Post)
+      end
     end
 
     protected
 
-    def construct_main_server_url(path)
-      if servers && servers.starts_with?("https:")
-        URI("#{servers}#{path}")
-      else
-        URI("https://www.elibri.com.pl#{path}")
-      end
-    end
-
     def get_response_from_server(uri, data, request_class)
       logger.info("doing #{uri}") if logger
       timestamp = Time.now.to_i.to_s
@@ -122,25 +93,20 @@ module ElibriWatermarking
       return validate_response(res)
     end
 
-    def try_with_different_servers(action)
-      txt_record = self.servers || Net::DNS::Resolver.start("transactional-servers.elibri.com.pl", Net::DNS::TXT).answer.first.txt
-      servers = txt_record.split(",").sort_by { rand }.map(&:strip)
-      servers.each do |server|
-        if server.starts_with?("https:")
-          uri = URI("#{server}/watermarking/#{action}")
-        else
-          uri = URI("https://#{server}.elibri.com.pl/watermarking/#{action}")
-        end
-        logger.info("trying #{uri}") if logger
-        begin
-          yield uri
-        rescue Timeout::Error, SystemCallError
-          logger.error($!) if logger
-        rescue ServerException
-          logger.error($!) if logger
-        end
+    def construct_url(action)
+      if action[0] == "/"
+        uri = URI("#{server}#{action}")
+      else
+        uri = URI("#{server}/transactional_api/#{action}")
+      end
+      logger.info("trying #{uri}") if logger
+      begin
+        yield uri
+      rescue Timeout::Error, SystemCallError
+        logger.error($!) if logger
+      rescue ServerException
+        logger.error($!) if logger
       end
-      raise NoWorkingServer.new("none of the servers #{servers.map { |s| "#{s}.elibri.com.pl" }.join(', ')} seems to work now")
     end
 
     def validate_response(res)

data/lib/elibri_watermarking/version.rb

@@ -1,3 +1,3 @@
 module ElibriWatermarking
-  VERSION = "0.9.12"
+  VERSION = "0.10.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: elibri_watermarking
 version: !ruby/object:Gem::Version
-  version: 0.9.12
+  version: 0.10.1
 platform: ruby
 authors:
 - Piotr Szmielew
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-07-04 00:00:00.000000000 Z
+date: 2023-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -75,7 +75,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.6
+rubygems_version: 3.4.17
 signing_key: 
 specification_version: 4
 summary: Gem designed to help in use of Elibri watermarking API.