authentise 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3a9cba594afbbcd29be2d1b3c1f29627e5ce6a95
-  data.tar.gz: 36659769fc84a3b1af0a4578476414654ebe0ddf
+  metadata.gz: 8f1e56dbfbd3c62ea57126745ef129b508795a75
+  data.tar.gz: a67c2a69f9ee8dad71424f044af0946a720eb839
 SHA512:
-  metadata.gz: e34a7b309ccc01ff79c2303f91e25ed6030a3987ef9b81c46bf5adcfd1747c635580aecd1395d7eabf943a78fc66d731d9b664f16f8bd45796696abc3e3e7d01
-  data.tar.gz: 06b4505e6f8b8ce98e7079ef647541bf0064bcb1538eb35fa3f63a028d6d52df5651cd32686cad7b2e784d86b75786e4f6efe72806dcbf4def069241bd6056d1
+  metadata.gz: 499c0b034752c6177b9ca3ab58fdc7f65408ab543171dc26f4df3866ffe0fb170713280b2d5fda6a0018d1d440bfca48bfbcb29ba73853342e938b53e2118029
+  data.tar.gz: 3c3fe5cf2b1dc67db778e6e076e81d775107d96cb946adceebb582825901b5c258bc6f0bf4798aa7a59a8e6c69cd5598c785aa1ebf77267f8e8bfb34e81d1f9f

data/README.md

@@ -1,48 +1,83 @@
 Ruby gem to access Authentise API v3
 ====================================
 
-See http://docs.dev-auth.com/
+See http://docs.authentise.com/model/reference.html
 
-Example usage
+Install
+-------
+
+Add the following line to your Gemfile:
+
+```rb
+gem "authentise"
+```
+
+
+Configuration
 -------------
 
+Set your secret partner key:
+
 ```rb
 Authentise.configure do |c|
   c.secret_partner_key = "ZSBzaG9y-dCB2ZWhl-bWVuY2Ug-b2YgYW55-IGNhcm5h-bCB=="
-  c.use_ssl = false
 end
+```
 
-upload = Authentise::Upload.new(
-  stl_file: File.new("example.stl", "rb"),
-  email: "example@example.com",
-  cents: 2_00,
-  currency: "EUR"
-)
+Usage
+------
 
-upload.token
-# => "33b41d6e80d4918cfff768185d1d31a6"
+### Authentication
 
-upload.link_url
-# => "https://widget.sendshapes.com/?token=33b41d6e80d4918cfff768185d1d31a6"
+```rb
+# Create a user
+user = Authentise::User.new(
+  email: 'you@example.com',
+  name: 'You',
+  username: 'you',
+  password: 'p4ssw0rd;99'
+)
+user.create
 
-upload.status
-# => {
-#  printing_job_status_name: "warming_up",
-#  printing_percentage: 0,
-#  minutes_left: 21,
-#  message: ""
-# }
+# Create a session
+session = Authentise::Session.new(
+  username: 'you',
+  password: 'p4ssw0rd;99'
+)
+session.create
 ```
 
-Install
--------
-
-Add the following line to your Gemfile:
+### Model Warehouse
 
 ```rb
-gem "authentise"
+# Create a model
+model = Authentise::Model.new(name: "My model")
+model.create(session_token: session.token)
+model.send_file(path: 'example.stl')
+model.url # => "https://models.authentise.com/model/42424…"
+
+# Get a model
+model = Authentise::Model.find_by_url(
+  url: "https://models.authentise.com/model/42424…",
+  session_token: session.token
+)
+model.name # => "My model"
+model.status # => "processing"
+model.content_url # => ""https://prod-hoth-models.s3.amazonaws.com:443/07c74a…"
 ```
 
+### Streaming iframe
+
+```rb
+# Create a print
+print = Authentise::Print.new(
+  model_url: "https://models.authentise.com/model/42424…"
+)
+
+# Show an iframe to this URL to the user
+print.url
+# => "https://widget.sendshapes.com/?token=33b41d6e80d4918cfff768185d1d31a6"
+
 
 Development
 -----------
@@ -59,6 +94,11 @@ To launch specs:
 $ rake
 ```
 
+List other tasks:
+
+```sh
+$ rake -T
+```
 
 License
 -------

data/lib/authentise/api/print.rb

@@ -0,0 +1,38 @@
+require "authentise/api"
+
+module Authentise
+  module API
+    # Calls to the print streaming API
+    module Print
+      module_function
+
+      def create_token(receiver_email: nil,
+                       model_url: nil,
+                       print_value: nil,
+                       print_value_currency: nil,
+                       partner_job_id: nil)
+        url = "https://print.authentise.com/token/"
+        body = {
+          api_key: Authentise.configuration.secret_partner_key,
+          model: model_url,
+          receiver_email: receiver_email,
+          print_value: print_value,
+          print_value_currency: print_value_currency,
+          partner_job_id: partner_job_id,
+        }.to_json
+        options = {
+          content_type: :json,
+          accept: :json,
+        }
+        RestClient.post(url, body, options) do |response, _request, _result|
+          if response.code == 201
+            { url: response.headers[:x_token_location] }
+          else
+            fail API::Error, response
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/authentise/api/users.rb

@@ -0,0 +1,64 @@
+require "authentise/api"
+
+module Authentise
+  module API
+    # Calls to create a user and authenticate over the API
+    module Users
+      module_function
+
+      # Create a new user to use the API.
+      #
+      # Params:
+      # - email
+      # - name
+      # - username
+      # - password
+      #
+      # Returns a hash with:
+      # - url: URL to the new user
+      # - uuid: unique id for this user
+      def create_user(params)
+        url = "https://users.authentise.com/users/"
+        options = {
+          accept: :json,
+        }
+        RestClient.post(url, params, options) do |response, _request, _result|
+          json = JSON.parse(response)
+          if response.code == 201
+            {
+              url: json["uri"],
+              uuid: json["uuid"],
+            }
+          else
+            fail API::Error, json["message"]
+          end
+        end
+      end
+
+      # Create a new session to use in other API calls.
+      #
+      # Params:
+      # - username
+      # - password
+      #
+      # Returns a hash with:
+      # - token: cookie token to add to the following API cooke calls
+      def create_session(params)
+        url = "https://users.authentise.com/sessions/"
+        options = {
+          accept: :json,
+        }
+        RestClient.post(url, params, options) do |response, _request, _result|
+          if response.code == 201
+            {
+              token: response.cookies["session"],
+            }
+          else
+            json = JSON.parse(response)
+            fail API::Error, json["message"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/authentise/api/warehouse.rb

@@ -0,0 +1,258 @@
+require "authentise/api"
+
+module Authentise
+  module API
+    # Upload models and take snapshot pictures
+    module Warehouse
+      module_function
+
+      # Params:
+      # - cookie
+      #
+      # - name (string) – Required. The name of the model. This can be any
+      #   string and should be meaningful to the user
+      #
+      # - allowed_transformations (hash) – Optional. The transformations that
+      #   are allowed on this model.
+      #   * resize (boolean) – Optional. true if this
+      #     model is allowed to be resized automatically by other services.
+      #     Default: false.
+      #   * rotation (boolean) – Optional. true if
+      #     this model is allowed to be rotated automatically by other services.
+      #     Default: false.
+      #
+      # - callback (hash) – Optional. The URL to call when this model changes
+      #   states.
+      #   * url (string) – Optional. The URL to request for the
+      #     callback
+      #   * method (string) – Optional. The method to use for the
+      #     request, one of GET, POST or PUT.
+      def create_model(session_token: nil, name: nil)
+        url = "https://models.authentise.com/model/"
+        body = {
+          name: name,
+        }.to_json
+        options = {
+          content_type: :json,
+          accept: :json,
+          cookies: { session: session_token },
+        }
+        RestClient.post(url, body, options) do |response, _request, _result|
+          if response.code == 201
+            {
+              model_url: response.headers[:location],
+              upload_url: response.headers[:x_upload_location],
+            }
+          else
+            fail API::Error, JSON.parse(response)["message"]
+          end
+        end
+      end
+
+      def put_file(url: nil, path: nil)
+        file = File.read(path)
+        options = {
+          content_type: 'application/octet-stream',
+        }
+        RestClient.put(url, file, options) do |response, _request, _result|
+          if response.code == 200
+            true
+          else
+            fail API::Error, response
+          end
+        end
+      end
+
+      # Get information about a model from its URL or UUID.
+      def get_model(url: nil, uuid: nil, session_token: nil)
+        url ||= "https://models.authentise.com/model/#{uuid}/"
+        headers = {
+          content_type: :json,
+          accept: :json,
+          cookies: { session: session_token },
+        }
+        RestClient.get(url, headers) do |response, _request, _result|
+          if response.code == 200
+            parse_model(response, url)
+          elsif response.code == 404
+            fail Authentise::API::NotFoundError
+          else
+            fail Authentise::API::Error, "Error #{response.code}"
+          end
+        end
+      end
+
+
+      # # Get a list of all models the requester has access to based on
+      # # query filters.
+      # #
+      # # Params:
+      # # - session_token
+      # # - name: a partial name of models to search for. accepts the
+      # #   wildcard character: “*”.
+      # # - status: a status of models to search for.
+      # # - created: a creation date to search for models.
+      # # - updated: a updated date to search for models.
+      # # - sort – one of the other queryable parameters, such as name,
+      # #   status, created or updated. accepts + or - to indicate order of
+      # #   the sort. parameters may be strung together, separated by commas.
+      # #   example: "+status, +created, -name" or "name, created"
+      # def get_models(params = {})
+      #   query = params.dup
+      #   session_token = query.delete(:session_token)
+
+      #   url = "https://models.authentise.com/model/"
+      #   options = {
+      #     params: query,
+      #     content_type: :json,
+      #     accept: :json,
+      #     cookies: { session: session_token }
+      #   }
+
+      #   RestClient.get(url, options) do |response, request, result|
+      #     if response.code == 200
+      #       data = JSON.parse(response)
+      #       p data
+      #       {
+      #         # ?
+      #         models: data["models"]
+      #       }
+      #     else
+      #       raise Authentise::API::Error, "Error #{response.code}"
+      #     end
+      #   end
+      # end
+
+
+      # Create a model snapshot.
+      #
+      # Required arguments:
+      # - session_token: for authentication.
+      # - model_uuid: which model to create a snapshot for.
+      #
+      # Optional arguments:
+      # - samples (int) – The number of samples to use in requesting the
+      #                 snapshot. Min 0, Max 5000. Higher numbers will take
+      #                 konger but yield better-looking results
+      # - layer (int) – The number of the layer of the model to show. This
+      #                 allows you to visualize the model when partially printed
+      # - color (string) – The color, in HTML color codes, to use for the
+      #                    material the model is made of. Ex: #AFAA75
+      # - height (int) – The height of the image in pixels. Min 0, Max 768
+      # - width (int) – The width oft he image in pixels. Min 0, Max 1024
+      # - x (float) – The position of the camera on the X axis
+      # - y (float) – The position of the camera on the Y axis
+      # - z (float) – The position of the camera on the Z axis
+      # - u (float) – The camera direction vector’s X component
+      # - v (float) – The camera direction vector’s Y component
+      # - w (float) – The camera direction vector’s Z component
+      # - callback (hash):
+      #   * url (string) – The url to callback to once model processing is
+      #                    finished.
+      #   * method (string) – The http method for the callback to use when
+      #                       calling back.
+      def create_snapshot(arguments = {})
+        params = arguments.dup
+        session_token = params.delete(:session_token)
+        model_uuid = params.delete(:model_uuid)
+
+        url = "https://models.authentise.com/model/#{model_uuid}/snapshot/"
+        body = params.to_json
+        headers = {
+          content_type: :json,
+          accept: :json,
+          cookies: { session: session_token },
+        }
+        RestClient.post(url, body, headers) do |response, _request, _result|
+          if response.code == 201
+            {
+              url: response.headers[:location],
+            }
+          else
+            fail API::Error, JSON.parse(response)["message"]
+          end
+        end
+      end
+
+
+      # Get information about a snapshot from its URL.
+      def get_snapshot(url: nil, session_token: nil)
+        headers = {
+          content_type: :json,
+          accept: :json,
+          cookies: { session: session_token },
+        }
+        RestClient.get(url, headers) do |response, _request, _result|
+          if response.code == 200
+            parse_snapshot(response)
+          elsif response.code == 404
+            fail Authentise::API::NotFoundError
+          else
+            fail Authentise::API::Error, "Error #{response.code}"
+          end
+        end
+      end
+
+
+      def parse_model(response, url)
+        data = JSON.parse(response)
+        {
+          # URL to fetch this model
+          url: url,
+          # Identifier for the model
+          uuid: url.split("/").last,
+          # The name of the model. (string)
+          name: data["name"],
+          # The current status of the model processing. Can be one of
+          # "processing", "processed", or "error".
+          status: data["status"],
+          # Link at which a snapshot of the model can be downloaded.
+          snapshot_url: data["snapshot"],
+          # Link at which a the model can be downloaded.
+          content_url: data["content"],
+          # Boolean represeting if the model is manifold. If the model is
+          # not manifold, there is a higher likelyhood that slicing will
+          # fail.
+          manifold: data["analyses.manifold"],
+          # The date and time the model was created.
+          created_at: parse_time(data["created"]),
+          # The date and time the model was last updated.
+          updated_at: parse_time(data["updated"]),
+          # An array of model uris from which this model is derived.
+          parents_urls: data["parents"],
+          #  An array of model uris from which are derived from this model.
+          children_urls: data["children"],
+        }
+      end
+      private_class_method :parse_model
+
+      # rubocop:disable Metrics/AbcSize
+      def parse_snapshot(response)
+        data = JSON.parse(response)
+        {
+          status: "snapshot_rendering",
+          samples: data["samples"],
+          layer: data["layer"],
+          color: data["color"],
+          height: data["height"],
+          width: data["width"],
+          x: data["x"],
+          y: data["y"],
+          z: data["z"],
+          u: data["u"],
+          v: data["v"],
+          w: data["w"],
+          slice_height: data["slice_height"],
+          created_at: parse_time(data["created"]),
+          content_url: data["content"],
+        }
+      end
+      # rubocop:enable Metrics/AbcSize
+
+      def parse_time(string)
+        string && Time.parse(string)
+      end
+      private_class_method :parse_time
+    end
+  end
+end

data/lib/authentise/api.rb

@@ -3,34 +3,41 @@ require "rest-client"
 require "authentise/configuration"
 
 module Authentise
+  # Module for all API-Related
   module API
+    # Common Error
     class Error < RuntimeError; end
 
-    CREATE_TOKEN_PATH = "api3/api_create_partner_token"
-    UPLOAD_FILE_PATH = "api3/api_upload_partner_stl"
-    STATUS_PATH = "api3/api_get_partner_print_status"
+    # 404 Error
+    class NotFoundError < Error; end
 
     module_function
 
+    # DEPRECATED, use Authentise::API::Print.create_token(…)
     def create_token
-      url = "#{host}/#{CREATE_TOKEN_PATH}"
+      url = "#{host}/api3/api_create_partner_token"
       params = {
-        api_key: Authentise.configuration.secret_partner_key
+        api_key: Authentise.configuration.secret_partner_key,
       }
       response = RestClient.get(url, params: params)
       data = parse(response)
       data["token"]
     end
 
-    def upload_file(file: nil, token: nil, email: nil, cents: nil, currency: "USD")
-      url = "#{host}/#{UPLOAD_FILE_PATH}"
+    # DEPRECATED, use Authentise::API::Print.create_token(…)
+    def upload_file(token: nil,
+                    file: nil,
+                    email: nil,
+                    cents: nil,
+                    currency: "USD")
+      url = "#{host}/api3/api_upload_partner_stl"
       params = {
         api_key: Authentise.configuration.secret_partner_key,
         token: token,
         receiver_email: email,
         print_value: cents,
         print_value_currency: currency,
-        stl_file: file
+        stl_file: file,
       }
       response = RestClient.post(url, params, accept: :json)
       data = parse(response)
@@ -42,6 +49,7 @@ module Authentise
       end
     end
 
+    # DEPRECATED
     # Returns a status hash for the given token if the print has started.
     # /!\ Do not call this more than once every 15 seconds.
     #
@@ -53,10 +61,10 @@ module Authentise
     # - `confirmed_success`
     # - `confirmed_failure`
     def get_status(token: nil)
-      url = "#{host}/#{STATUS_PATH}"
+      url = "#{host}/api3/api_get_partner_print_status"
       params = {
         api_key: Authentise.configuration.secret_partner_key,
-        token: token
+        token: token,
       }
       response = RestClient.get(url, params: params)
       data = parse(response)
@@ -64,15 +72,15 @@ module Authentise
         printing_job_status_name: data["printing_job_status_name"].downcase,
         printing_percentage: data["printing_percentage"],
         minutes_left: data["minutes_left"],
-        message: data["message"]
+        message: data["message"],
       }
     end
 
-    private_class_method
+    # private
 
     def parse(response)
       json = JSON.parse(response)
-      if json["status"] and json["status"]["code"] != "ok"
+      if json["status"] && json["status"]["code"] != "ok"
         fail Error, json["status"]["extended_description"]
       elsif json["data"]
         json["data"]
@@ -80,6 +88,7 @@ module Authentise
         fail Error, "JSON with no data: #{response}"
       end
     end
+    private_class_method :parse
 
     def host
       if Authentise.configuration.use_ssl
@@ -88,5 +97,6 @@ module Authentise
         "http://widget.sendshapes.com:3000"
       end
     end
+    private_class_method :host
   end
 end

data/lib/authentise/configuration.rb

@@ -1,6 +1,16 @@
+# Configure your application using this construct:
+#
+#   Authentise.configure do |c|
+#     c.secret_partner_key = "…"
+#   end
 module Authentise
+  # Store the config
   class Configuration
+    # The partner key Authentise gave you
     attr_accessor :secret_partner_key
+
+    # DEPRECATED
+    # Switch off the use of SSL for the old streaming API
     attr_accessor :use_ssl
 
     def initialize

data/lib/authentise/model.rb

@@ -0,0 +1,88 @@
+require "authentise/api/warehouse"
+
+module Authentise
+  # Represents a model in the Model Warehouse
+  class Model
+    attr_accessor :name, # Required
+
+                  # Available only when model is created or fetched
+                  :url,
+
+                  # Available only when model is created
+                  :upload_url,
+
+                  # Available only when model is fetched
+                  :status,
+                  :snapshot_url,
+                  :content_url,
+                  :manifold,
+                  :created_at,
+                  :updated_at,
+                  :parents_urls,
+                  :children_urls,
+
+                  # You can initialize a model with it but it is not available
+                  # when fetched
+                  :uuid
+
+
+    def initialize(name: nil,
+                   url: nil,
+                   upload_url: nil,
+                   uuid: nil)
+      @name = name
+      @upload_url = upload_url
+      @url = url
+      @uuid = uuid
+    end
+
+    def create(session_token: nil)
+      response = API::Warehouse.create_model(
+        session_token: session_token,
+        name: name,
+      )
+      @upload_url = response[:upload_url]
+      @url = response[:model_url]
+      true
+    end
+
+    def send_file(path: nil)
+      API::Warehouse.put_file(
+        url: upload_url,
+        path: path,
+      )
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def fetch(session_token: nil)
+      response = API::Warehouse.get_model(uuid: uuid,
+                                          url: url,
+                                          session_token: session_token)
+      @url = response[:url]
+      @uuid = response[:uuid]
+      @name = response[:name]
+      @status = response[:status]
+      @snapshot_url = response[:snapshot_url]
+      @content_url = response[:content_url]
+      @manifold = response[:manifold]
+      @parents_urls = response[:parents_urls]
+      @children_urls = response[:children_urls]
+      @created_at = response[:created_at]
+      @updated_at = response[:updated_at]
+      true
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def self.find_by_url(url: nil, session_token: nil)
+      model = new(url: url)
+      model.fetch(session_token: session_token)
+      model
+    end
+
+    def self.find_by_uuid(uuid: nil, session_token: nil)
+      model = new(uuid: uuid)
+      model.fetch(session_token: session_token)
+      model
+    end
+  end
+end