warrant 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d582aad391d045a0560fa31d72874b6daab745730fde4166a8a928372b0dfd1a
-  data.tar.gz: b8b88e6cb72cca841e4261460a9562c3f6228894cab278c88de4bb69b4838aeb
+  metadata.gz: a62cf14af95db8e5b31f60059a2a826a67c067239edb5f6c63cf02426df3ae21
+  data.tar.gz: bdc8aa083993566c57760d484e043ad3ed64abe2bf1945ebad2428c2eb497551
 SHA512:
-  metadata.gz: af98bc58266547012886473b49d3d8e0a4434e922dedc6d7372fb4b1d90f95d7d77cdba276281dde5f0316ffa4ba60b575d9331ba0f30774fbe2cc30d7cbafe3
-  data.tar.gz: d99f3dccc78f9855ff239671ebde3ac5903e26311e4c1a2d2122ff864fa642b1801d03529a713037de26c510dc6030e32c2fb276bb779206aba8e532d44830de
+  metadata.gz: 36cf1f6120b776293513e49d5554aa70a8ff22e671105072e2f04115d1e00bc852fd4cc5326672ae9ad246f35f069718272f2abf957ff9abe27ebeed0b564efc
+  data.tar.gz: 4377ab4955b67e922622ef8c10c50c17d3281d097ec62df85ce31779df3554d8326121622024ffde252abf1a3c13655d0e3f6251d898fc78f722a1578b091daa

data/README.md

@@ -28,19 +28,19 @@ require 'warrant'
 Warrant.api_key = 'api_test_f5dsKVeYnVSLHGje44zAygqgqXiLJBICbFzCiAg1E='
 ```
 
-### `createUser(user_id, username)`
+### `create_user(email, user_id = '', tenant_id = '')`
 
 This method creates a user entity in Warrant with the specified `userId`. Provide an optional `username` to make it easier to identify users in the Warrant dashboard.
 
 ```ruby
-# Create user with `user.id` as the user_id and `user.email` as the username
-Warrant::WarrantClient.create_user(user.id, user.email)
+# Create user with user email and id
+Warrant::WarrantClient.create_user(user.email, user.id)
 
 # Create user with generated id
 Warrant::WarrantClient.create_user()
 ```
 
-### `createWarrant(objectType, objectId, relation, user)`
+### `create_warrant(objectType, objectId, relation, user)`
 
 This method creates a warrant which specifies that the provided `user` (or userset) has `relation` on the object of type `objectType` with id `objectId`.
 
@@ -49,7 +49,7 @@ This method creates a warrant which specifies that the provided `user` (or users
 Warrant::WarrantClient.create_warrant('store', store.id, 'view', { userId: user.id })
 ```
 
-### `createSession(userId)`
+### `create_session(userId)`
 
 This method creates a session in Warrant for the user with the specified `userId` and returns a session token which can be used to make authorized requests to the Warrant API only for the specified user. This session token can safely be used to make requests to the Warrant API's authorization endpoint to determine user access in web and mobile client applications.
 
@@ -58,7 +58,7 @@ This method creates a session in Warrant for the user with the specified `userId
 Warrant::WarrantClient.create_session(user.id)
 ```
 
-### `isAuthorized(objectType, objectId, relation, userId)`
+### `is_authorized(objectType, objectId, relation, userId)`
 
 This method returns `true` if the user with the specified `userId` has the specified `relation` to the object of type `objectType` with id `objectId` and `false` otherwise.
 
@@ -68,6 +68,34 @@ Warrant::WarrantClient.is_authorized('store', '824', 'view', '123') # true
 Warrant::WarrantClient.is_authorized('store', '824', 'edit', '123') # false
 ```
 
+### `list_warrants(filters = {})`
+This method returns all warrants that match the filters provided, or all warrants for your organization if none are provided. 
+
+#### **Filter Parameters** 
+---
+#### **objectType**
+Only return warrants with the given object type.
+
+#### **objectId**
+Only return warrants with the given object id.
+
+#### **relation**
+Only return warrants with the given relation.
+
+#### **userId**
+Only return warrants with the given user id
+
+
+```ruby
+# List all warrants for an organization
+Warrant::WarrantClient.list_warrants
+
+# List all warrants with object type of store
+Warrant::WarrantClient.list_warrants(object_type: 'store')
+```
+
+---
+
 We’ve used a random API key in these code examples. Replace it with your [actual publishable API keys](https://app.warrant.dev) to
 test this code through your own Warrant account.
 

data/lib/warrant/models/permission.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Warrant
+    class Permission
+        attr_reader :permission_id
+
+        def initialize(permission_id)
+            @permission_id = permission_id
+        end
+    end
+end

data/lib/warrant/models/role.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Warrant
+    class Role
+        attr_reader :role_id
+
+        def initialize(role_id)
+            @role_id = role_id
+        end
+    end
+end

data/lib/warrant/models/tenant.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Warrant
+    class Tenant
+        attr_reader :tenant_id
+
+        def initialize(tenant_id)
+            @tenant_id = tenant_id
+        end
+    end
+end

data/lib/warrant/models/user.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 module Warrant
-  class User
-    attr_reader :user_id
+    class User
+        attr_reader :tenant_id, :user_id, :email
 
-    def initialize(user_id)
-      @user_id = user_id
+        def initialize(tenant_id, user_id, email)
+            @tenant_id = tenant_id
+            @user_id = user_id
+            @email = email
+        end
     end
-  end
 end

data/lib/warrant/models/{userset_warrant.rb → warrant.rb}

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 module Warrant
-    class UsersetWarrant
-        attr_reader :object_type, :object_id, :relation, :user
+    class Warrant
+        attr_reader :id, :object_type, :object_id, :relation, :user
 
-        def initialize(object_type, object_id, relation, user)
+        def initialize(id, object_type, object_id, relation, user)
+            @id = id
             @object_type = object_type
             @object_id = object_id
             @relation = relation

data/lib/warrant/util.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Warrant
+    class Util
+        class << self
+            def camelcase(str)
+                str = str.split('_').collect(&:capitalize).join
+                str.sub(str[0], str[0].downcase)
+            end
+
+            def normalize_options(opts)
+                new_opts = opts.each_with_object({}) do |(k, v), new_opts|
+                    new_key = Util.camelcase(k.to_s)
+
+                    new_opts[new_key] = v
+                end
+            end
+        end
+    end
+end

data/lib/warrant/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Warrant
-  VERSION = "0.1.0"
+  VERSION = "0.1.3"
 end

data/lib/warrant/warrant_client.rb

@@ -3,25 +3,98 @@
 module Warrant
     class WarrantClient
         class << self
-            def create_user(user_id = '', username = '')
-                uri = URI.parse("#{Warrant.config.api_base}/v1/users")
+            def create_tenant(tenant_id = '')
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/tenants")
                 params = {
+                    tenantId: tenant_id
+                }
+                res = post(uri, params)
+                res_json = JSON.parse(res.body)
+
+                case res
+                when Net::HTTPSuccess
+                    Tenant.new(res_json['tenantId'])
+                else
+                    res_json
+                end
+            end
+
+            def create_user(email, user_id = '', tenant_id = '')
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/users")
+                params = {
+                    tenantId: tenant_id,
                     userId: user_id,
-                    username: username
+                    email: email
                 }
                 res = post(uri, params)
                 res_json = JSON.parse(res.body)
-                
+
                 case res
                 when Net::HTTPSuccess
-                    User.new(res_json['userId'])
+                    User.new(res_json['tenantId'], res_json['userId'], res_json['email'])
+                else
+                    res_json
+                end
+            end
+
+            def create_role(role_id)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/roles")
+                params = {
+                    roleId: role_id
+                }
+                res = post(uri, params)
+                res_json = JSON.parse(res.body)
+
+                case res
+                when Net::HTTPSuccess
+                    Role.new(res_json['roleId'])
+                else
+                    res_json
+                end
+            end
+
+            def delete_role(role_id)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/roles/#{role_id}")
+                res = delete(uri)
+
+                case res
+                when Net::HTTPSuccess
+                    return
+                else
+                    res_json
+                end
+            end
+
+            def create_permission(permission_id)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/permissions")
+                params = {
+                    permissionId: permission_id
+                }
+                res = post(uri, params)
+                res_json = JSON.parse(res.body)
+
+                case res
+                when Net::HTTPSuccess
+                    Permission.new(res_json['permissionId'])
+                else
+                    res_json
+                end
+            end
+
+            def delete_permission(permission_id)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/permissions/#{permission_id}")
+                res = delete(uri)
+
+                case res
+                when Net::HTTPSuccess
+                    return
                 else
                     res_json
                 end
             end
 
             def create_warrant(object_type, object_id, relation, user)
-                uri = URI.parse("#{Warrant.config.api_base}/v1/warrants")
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/warrants")
                 params = {
                     objectType: object_type,
                     objectId: object_id,
@@ -30,21 +103,102 @@ module Warrant
                 }
                 res = post(uri, params)
                 res_json = JSON.parse(res.body)
-                
+
+                case res
+                when Net::HTTPSuccess
+                    Warrant.new(res_json['id'], res_json['objectType'], res_json['objectId'], res_json['relation'], res_json['user'])
+                else
+                    res_json
+                end
+            end
+
+            def delete_warrant(warrant_id)
+                uri = URI.parse("#{Warrant.config.api_base}/v1/warrants/#{warrant_id}")
+                res = delete(uri)
+
+                case res
+                when Net::HTTPSuccess
+                    return
+                else
+                    res_json
+                end
+            end
+
+            def list_warrants(filters = {})
+                query_string = ""
+                unless filters.empty?
+                    new_filters = Util.normalize_options(filters.compact)
+
+                    query_string = URI.encode_www_form(new_filters) 
+                end
+
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/warrants?#{query_string}")
+
+                res = get(uri)
+                res_json = JSON.parse(res.body)
+
                 case res
                 when Net::HTTPSuccess
-                    if res_json['user']['userId']
-                        UserWarrant.new(res_json['objectType'], res_json['objectId'], res_json['relation'], res_json['user']['userId'])
-                    elsif res_json['user']['objectType']
-                        UsersetWarrant.new(res_json['objectType'], res_json['objectId'], res_json['relation'], res_json['user'])
+                    res_json.map do |warrant|
+                        Warrant.new(warrant['id'], warrant['objectType'], warrant['objectId'], warrant['relation'], warrant['user'])
                     end
                 else
                     res_json
                 end
             end
 
+            def assign_role_to_user(user_id, role_id)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/users/#{user_id}/roles/#{role_id}")
+                res = post(uri)
+                res_json = JSON.parse(res.body)
+
+                case res
+                when Net::HTTPSuccess
+                    Role.new(res_json['roleId'])
+                else
+                    res_json
+                end
+            end
+
+            def remove_role_from_user(user_id, role_id)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/users/#{user_id}/roles/#{role_id}")
+                res = delete(uri)
+
+                case res
+                when Net::HTTPSuccess
+                    return
+                else
+                    res_json
+                end
+            end
+
+            def assign_permission_to_user(user_id, permission_id)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/users/#{user_id}/permissions/#{permission_id}")
+                res = post(uri)
+                res_json = JSON.parse(res.body)
+
+                case res
+                when Net::HTTPSuccess
+                    Permission.new(res_json['permissionId'])
+                else
+                    res_json
+                end
+            end
+
+            def remove_permission_from_user(user_id, permission_id)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/users/#{user_id}/permissions/#{permission_id}")
+                res = delete(uri)
+
+                case res
+                when Net::HTTPSuccess
+                    return
+                else
+                    res_json
+                end
+            end
+
             def create_session(user_id)
-                uri = URI.parse("#{Warrant.config.api_base}/v1/users/#{user_id}/sessions")
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/users/#{user_id}/sessions")
                 res = post(uri)
                 res_json = JSON.parse(res.body)
 
@@ -56,8 +210,26 @@ module Warrant
                 end
             end
 
+            def create_self_service_session(user_id, redirect_url)
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/sessions")
+                params = {
+                    type: "ssdash",
+                    userId: user_id,
+                    redirectUrl: redirect_url
+                }
+                res = post(uri, params)
+                res_json = JSON.parse(res.body)
+
+                case res
+                when Net::HTTPSuccess
+                    res_json['url']
+                else
+                    res_json
+                end
+            end
+
             def is_authorized(object_type, object_id, relation, user_id)
-                uri = URI.parse("#{Warrant.config.api_base}/v1/authorize")
+                uri = URI.parse("#{::Warrant.config.api_base}/v1/authorize")
                 params = {
                     objectType: object_type,
                     objectId: object_id,
@@ -76,16 +248,38 @@ module Warrant
                 end
             end
 
+            def has_permission(permission_id, user_id)
+                return is_authorized("permission", permission_id, "member", user_id)
+            end
+
             private
 
-            def post(uri, params = {}) 
+            def post(uri, params = {})
                 http = Net::HTTP.new(uri.host, uri.port)
                 http.use_ssl = true
                 headers = {
-                    "Authorization": "ApiKey #{Warrant.config.api_key}"
+                    "Authorization": "ApiKey #{::Warrant.config.api_key}"
                 }
                 http.post(uri.path, params.to_json, headers)
             end
+
+            def delete(uri)
+                http = Net::HTTP.new(uri.host, uri.port)
+                http.use_ssl = true
+                headers = {
+                    "Authorization": "ApiKey #{::Warrant.config.api_key}"
+                }
+                http.delete(uri.path, headers)
+            end
+
+            def get(uri, params = {})
+                http = Net::HTTP.new(uri.host, uri.port)
+                http.use_ssl = true
+                headers = {
+                    "Authorization": "ApiKey #{::Warrant.config.api_key}"
+                }
+                http.get(uri, headers)
+            end
         end
     end
 end

data/lib/warrant.rb

@@ -6,15 +6,18 @@ require "net/http"
 require "json"
 require "forwardable"
 
+require "warrant/models/permission"
+require "warrant/models/role"
+require "warrant/models/tenant"
 require "warrant/models/user"
 require "warrant/models/userset"
-require "warrant/models/user_warrant"
-require "warrant/models/userset_warrant"
+require "warrant/models/warrant"
+require "warrant/util"
 require "warrant/warrant_configuration"
 require "warrant/warrant_client"
 
 module Warrant
-    @config = Warrant::WarrantConfiguration.new
+    @config = ::Warrant::WarrantConfiguration.new
 
     class << self
         extend Forwardable

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: warrant
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.3
 platform: ruby
 authors:
 - Warrant
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-11-23 00:00:00.000000000 Z
+date: 2022-05-09 00:00:00.000000000 Z
 dependencies: []
 description: Ruby library for the Warrant API at https://warrant.dev.
 email: hello@warrant.dev
@@ -26,10 +26,13 @@ files:
 - bin/console
 - bin/setup
 - lib/warrant.rb
+- lib/warrant/models/permission.rb
+- lib/warrant/models/role.rb
+- lib/warrant/models/tenant.rb
 - lib/warrant/models/user.rb
-- lib/warrant/models/user_warrant.rb
 - lib/warrant/models/userset.rb
-- lib/warrant/models/userset_warrant.rb
+- lib/warrant/models/warrant.rb
+- lib/warrant/util.rb
 - lib/warrant/version.rb
 - lib/warrant/warrant_client.rb
 - lib/warrant/warrant_configuration.rb
@@ -41,7 +44,7 @@ metadata:
   source_code_uri: https://github.com/warrant-dev/warrant-ruby
   changelog_uri: https://github.com/warrant-dev/warrant-ruby/CHANGELOG.md
   documentation_uri: https://docs.warrant.dev/
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -56,8 +59,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.14
-signing_key: 
+rubygems_version: 3.3.11
+signing_key:
 specification_version: 4
 summary: Warrant Ruby Library
 test_files: []

data/lib/warrant/models/user_warrant.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-module Warrant
-    class UserWarrant
-        attr_reader :object_type, :object_id, :relation, :user
-
-        def initialize(object_type, object_id, relation, user_id)
-            @object_type = object_type
-            @object_id = object_id
-            @relation = relation
-            @user = User.new(user_id)
-        end
-    end
-end