keycloak-admin 1.1.4 → 1.1.6

data/lib/keycloak-admin/client/group_client.rb

@@ -1,148 +1,148 @@
-module KeycloakAdmin
-  class GroupClient < Client
-    def initialize(configuration, realm_client)
-      super(configuration)
-      raise ArgumentError.new("realm must be defined") unless realm_client.name_defined?
-      @realm_client = realm_client
-    end
-
-    def get(group_id)
-      response = execute_http do
-        RestClient::Resource.new(groups_url(group_id), @configuration.rest_client_options).get(headers)
-      end
-      GroupRepresentation.from_hash(JSON.parse(response))
-    end
-
-    def children(parent_id)
-      response = execute_http do
-        url = "#{groups_url(parent_id)}/children"
-        RestClient::Resource.new(url, @configuration.rest_client_options).get(headers)
-      end
-      JSON.parse(response).map { |group_as_hash| GroupRepresentation.from_hash(group_as_hash) }
-    end
-
-    def list
-      search(nil)
-    end
-
-    def search(query)
-      derived_headers = case query
-                        when String
-                          headers.merge({params: { search: query }})
-                        when Hash
-                          headers.merge({params: query })
-                        else
-                          headers
-                        end
-      response = execute_http do
-        RestClient::Resource.new(groups_url, @configuration.rest_client_options).get(derived_headers)
-      end
-      JSON.parse(response).map { |group_as_hash| GroupRepresentation.from_hash(group_as_hash) }
-    end
-
-    def create!(name, path = nil, attributes = {})
-      response = save(build(name, path, attributes))
-      created_id(response)
-    end
-
-    def save(group_representation)
-      execute_http do
-        payload = create_payload(group_representation)
-        if group_representation.id
-          RestClient::Resource.new(groups_url(group_representation.id), @configuration.rest_client_options).put(payload, headers)
-        else
-          RestClient::Resource.new(groups_url, @configuration.rest_client_options).post(payload, headers)
-        end
-      end
-    end
-
-    def create_subgroup!(parent_id, name, attributes = {})
-      url = "#{groups_url(parent_id)}/children"
-      response = execute_http do
-        RestClient::Resource.new(url, @configuration.rest_client_options).post(
-          create_payload(build(name, nil, attributes)), headers
-        )
-      end
-      created_id(response)
-    end
-
-    def delete(group_id)
-      execute_http do
-        RestClient::Resource.new(groups_url(group_id), @configuration.rest_client_options).delete(headers)
-      end
-      true
-    end
-
-    def members(group_id, first=0, max=100)
-      url = "#{groups_url(group_id)}/members"
-      query = {first: first.try(:to_i), max: max.try(:to_i)}.compact
-      unless query.empty?
-        query_string = query.to_a.map { |e| "#{e[0]}=#{e[1]}" }.join("&")
-        url = "#{url}?#{query_string}"
-      end
-      response = execute_http do
-        RestClient::Resource.new(url, @configuration.rest_client_options).get(headers)
-      end
-      JSON.parse(response).map { |user_as_hash| UserRepresentation.from_hash(user_as_hash) }
-    end
-
-    # Gets all realm-level roles for a group
-    def get_realm_level_roles(group_id)
-      url = "#{groups_url(group_id)}/role-mappings/realm"
-      response = execute_http do
-        RestClient::Resource.new(url, @configuration.rest_client_options).get(headers)
-      end
-      JSON.parse(response).map { |role_as_hash| RoleRepresentation.from_hash(role_as_hash) }
-    end
-
-    # Adds a realm-level role to a group via the role name
-    def add_realm_level_role_name!(group_id, role_name)
-      # creates a full role-representation object needed by the keycloak api to work
-      role_representation = RoleClient.new(@configuration, @realm_client).get(role_name)
-      url = "#{groups_url(group_id)}/role-mappings/realm"
-      response = execute_http do
-        RestClient::Resource.new(url, @configuration.rest_client_options).post(
-          create_payload([role_representation]), headers
-        )
-      end
-      role_representation
-    end
-
-    # Remove a realm-level role from a group by the role name
-    def remove_realm_level_role_name!(group_id, role_name)
-      role_representation = RoleClient.new(@configuration, @realm_client).get(role_name)
-      url = "#{groups_url(group_id)}/role-mappings/realm"
-      execute_http do
-        RestClient::Request.execute(
-          @configuration.rest_client_options.merge(
-            url:,
-            method: :delete,
-            payload: create_payload([role_representation]),
-            headers: headers
-          )
-        )
-      end
-      true
-    end
-
-    def groups_url(id=nil)
-      if id
-        "#{@realm_client.realm_admin_url}/groups/#{id}"
-      else
-        "#{@realm_client.realm_admin_url}/groups"
-      end
-    end
-
-    private
-
-    def build(name, path, attributes)
-      GroupRepresentation.from_hash(
-        {
-          "name" => name,
-          "path" => path,
-          "attributes" => attributes
-        }
-      )
-    end
-  end
-end
+module KeycloakAdmin
+  class GroupClient < Client
+    def initialize(configuration, realm_client)
+      super(configuration)
+      raise ArgumentError.new("realm must be defined") unless realm_client.name_defined?
+      @realm_client = realm_client
+    end
+
+    def get(group_id)
+      response = execute_http do
+        RestClient::Resource.new(groups_url(group_id), @configuration.rest_client_options).get(headers)
+      end
+      GroupRepresentation.from_hash(JSON.parse(response))
+    end
+
+    def children(parent_id)
+      response = execute_http do
+        url = "#{groups_url(parent_id)}/children"
+        RestClient::Resource.new(url, @configuration.rest_client_options).get(headers)
+      end
+      JSON.parse(response).map { |group_as_hash| GroupRepresentation.from_hash(group_as_hash) }
+    end
+
+    def list
+      search(nil)
+    end
+
+    def search(query)
+      derived_headers = case query
+                        when String
+                          headers.merge({params: { search: query }})
+                        when Hash
+                          headers.merge({params: query })
+                        else
+                          headers
+                        end
+      response = execute_http do
+        RestClient::Resource.new(groups_url, @configuration.rest_client_options).get(derived_headers)
+      end
+      JSON.parse(response).map { |group_as_hash| GroupRepresentation.from_hash(group_as_hash) }
+    end
+
+    def create!(name, path = nil, attributes = {})
+      response = save(build(name, path, attributes))
+      created_id(response)
+    end
+
+    def save(group_representation)
+      execute_http do
+        payload = create_payload(group_representation)
+        if group_representation.id
+          RestClient::Resource.new(groups_url(group_representation.id), @configuration.rest_client_options).put(payload, headers)
+        else
+          RestClient::Resource.new(groups_url, @configuration.rest_client_options).post(payload, headers)
+        end
+      end
+    end
+
+    def create_subgroup!(parent_id, name, attributes = {})
+      url = "#{groups_url(parent_id)}/children"
+      response = execute_http do
+        RestClient::Resource.new(url, @configuration.rest_client_options).post(
+          create_payload(build(name, nil, attributes)), headers
+        )
+      end
+      created_id(response)
+    end
+
+    def delete(group_id)
+      execute_http do
+        RestClient::Resource.new(groups_url(group_id), @configuration.rest_client_options).delete(headers)
+      end
+      true
+    end
+
+    def members(group_id, first=0, max=100)
+      url = "#{groups_url(group_id)}/members"
+      query = {first: first.try(:to_i), max: max.try(:to_i)}.compact
+      unless query.empty?
+        query_string = query.to_a.map { |e| "#{e[0]}=#{e[1]}" }.join("&")
+        url = "#{url}?#{query_string}"
+      end
+      response = execute_http do
+        RestClient::Resource.new(url, @configuration.rest_client_options).get(headers)
+      end
+      JSON.parse(response).map { |user_as_hash| UserRepresentation.from_hash(user_as_hash) }
+    end
+
+    # Gets all realm-level roles for a group
+    def get_realm_level_roles(group_id)
+      url = "#{groups_url(group_id)}/role-mappings/realm"
+      response = execute_http do
+        RestClient::Resource.new(url, @configuration.rest_client_options).get(headers)
+      end
+      JSON.parse(response).map { |role_as_hash| RoleRepresentation.from_hash(role_as_hash) }
+    end
+
+    # Adds a realm-level role to a group via the role name
+    def add_realm_level_role_name!(group_id, role_name)
+      # creates a full role-representation object needed by the keycloak api to work
+      role_representation = RoleClient.new(@configuration, @realm_client).get(role_name)
+      url = "#{groups_url(group_id)}/role-mappings/realm"
+      response = execute_http do
+        RestClient::Resource.new(url, @configuration.rest_client_options).post(
+          create_payload([role_representation]), headers
+        )
+      end
+      role_representation
+    end
+
+    # Remove a realm-level role from a group by the role name
+    def remove_realm_level_role_name!(group_id, role_name)
+      role_representation = RoleClient.new(@configuration, @realm_client).get(role_name)
+      url = "#{groups_url(group_id)}/role-mappings/realm"
+      execute_http do
+        RestClient::Request.execute(
+          @configuration.rest_client_options.merge(
+            url:,
+            method: :delete,
+            payload: create_payload([role_representation]),
+            headers: headers
+          )
+        )
+      end
+      true
+    end
+
+    def groups_url(id=nil)
+      if id
+        "#{@realm_client.realm_admin_url}/groups/#{id}"
+      else
+        "#{@realm_client.realm_admin_url}/groups"
+      end
+    end
+
+    private
+
+    def build(name, path, attributes)
+      GroupRepresentation.from_hash(
+        {
+          "name" => name,
+          "path" => path,
+          "attributes" => attributes
+        }
+      )
+    end
+  end
+end

data/lib/keycloak-admin/client/identity_provider_client.rb

@@ -1,51 +1,51 @@
-module KeycloakAdmin
-  class IdentityProviderClient < Client
-    def initialize(configuration, realm_client)
-      super(configuration)
-      raise ArgumentError.new("realm must be defined") unless realm_client.name_defined?
-      @realm_client = realm_client
-    end
-
-    def create(identity_provider_representation)
-      execute_http do
-        RestClient::Resource.new(identity_providers_url, @configuration.rest_client_options).post(
-          create_payload(identity_provider_representation), headers
-        )
-      end
-    end
-
-    def add_mapping(identity_provider_alias, identity_provider_mapping_representation)
-      execute_http do
-        RestClient::Resource.new(identity_provider_mappers_url(identity_provider_alias), @configuration.rest_client_options).post(
-          create_payload(identity_provider_mapping_representation), headers
-        )
-      end
-    end
-
-    def list
-      response = execute_http do
-        RestClient::Resource.new(identity_providers_url, @configuration.rest_client_options).get(headers)
-      end
-      JSON.parse(response).map { |provider_as_hash| IdentityProviderRepresentation.from_hash(provider_as_hash) }
-    end
-
-    def get(internal_id_or_alias=nil)
-      response = execute_http do
-        RestClient::Resource.new(identity_providers_url(internal_id_or_alias), @configuration.rest_client_options).get(headers)
-      end
-      IdentityProviderRepresentation.from_hash(JSON.parse(response))
-    end
-
-    def identity_providers_url(internal_id_or_alias=nil)
-      if internal_id_or_alias
-        "#{@realm_client.realm_admin_url}/identity-provider/instances/#{internal_id_or_alias}"
-      else
-        "#{@realm_client.realm_admin_url}/identity-provider/instances"
-      end
-    end
-
-    def identity_provider_mappers_url(internal_id_or_alias)
-      "#{identity_providers_url(internal_id_or_alias)}/mappers"
-    end
-  end
-end
+module KeycloakAdmin
+  class IdentityProviderClient < Client
+    def initialize(configuration, realm_client)
+      super(configuration)
+      raise ArgumentError.new("realm must be defined") unless realm_client.name_defined?
+      @realm_client = realm_client
+    end
+
+    def create(identity_provider_representation)
+      execute_http do
+        RestClient::Resource.new(identity_providers_url, @configuration.rest_client_options).post(
+          create_payload(identity_provider_representation), headers
+        )
+      end
+    end
+
+    def add_mapping(identity_provider_alias, identity_provider_mapping_representation)
+      execute_http do
+        RestClient::Resource.new(identity_provider_mappers_url(identity_provider_alias), @configuration.rest_client_options).post(
+          create_payload(identity_provider_mapping_representation), headers
+        )
+      end
+    end
+
+    def list
+      response = execute_http do
+        RestClient::Resource.new(identity_providers_url, @configuration.rest_client_options).get(headers)
+      end
+      JSON.parse(response).map { |provider_as_hash| IdentityProviderRepresentation.from_hash(provider_as_hash) }
+    end
+
+    def get(internal_id_or_alias=nil)
+      response = execute_http do
+        RestClient::Resource.new(identity_providers_url(internal_id_or_alias), @configuration.rest_client_options).get(headers)
+      end
+      IdentityProviderRepresentation.from_hash(JSON.parse(response))
+    end
+
+    def identity_providers_url(internal_id_or_alias=nil)
+      if internal_id_or_alias
+        "#{@realm_client.realm_admin_url}/identity-provider/instances/#{internal_id_or_alias}"
+      else
+        "#{@realm_client.realm_admin_url}/identity-provider/instances"
+      end
+    end
+
+    def identity_provider_mappers_url(internal_id_or_alias)
+      "#{identity_providers_url(internal_id_or_alias)}/mappers"
+    end
+  end
+end

data/lib/keycloak-admin/client/organization_client.rb

@@ -0,0 +1,245 @@
+module KeycloakAdmin
+  class OrganizationClient < Client
+    def initialize(configuration, realm_client)
+      super(configuration)
+      raise ArgumentError.new("realm must be defined") unless realm_client.name_defined?
+      @realm_client = realm_client
+    end
+
+    # This endpoint does not return members
+    def list(brief_representation=true, exact=nil, first=nil, max=nil, query=nil, search=nil)
+      response = execute_http do
+        RestClient::Resource.new(organizations_url_with_parameters(brief_representation, exact, first, max, query, search), @configuration.rest_client_options).get(headers)
+      end
+      JSON.parse(response).map { |organization_as_hash| OrganizationRepresentation.from_hash(organization_as_hash) }
+    end
+
+    def count(exact=nil, query=nil, search=nil)
+      response = execute_http do
+        RestClient::Resource.new(count_url(exact, query, search), @configuration.rest_client_options).get(headers)
+      end
+      response.to_i
+    end
+
+    def delete(organization_id)
+      execute_http do
+        RestClient::Resource.new(organization_url(organization_id), @configuration.rest_client_options).delete(headers)
+      end
+      true
+    end
+
+    def update(organization_representation)
+      execute_http do
+        RestClient::Resource.new(organization_url(organization_representation.id), @configuration.rest_client_options).put(
+          create_payload(organization_representation), headers
+        )
+      end
+
+      get(organization_representation.id)
+    end
+
+    def create!(name, alias_name, enabled, description, redirect_url=nil, domains=[], attributes={})
+      save(build(name, alias_name, enabled, description, redirect_url, domains, attributes))
+    end
+
+    # This operation does not associate members and identity providers
+    def save(organization_representation)
+      execute_http do
+        RestClient::Resource.new(organizations_url, @configuration.rest_client_options).post(
+          create_payload(organization_representation), headers
+        )
+      end
+      true
+    end
+
+    def get(organization_id)
+      response = execute_http do
+        RestClient::Resource.new(organization_url(organization_id), @configuration.rest_client_options).get(headers)
+      end
+      OrganizationRepresentation.from_hash(JSON.parse(response))
+    end
+
+    def identity_providers(organization_id)
+      response = execute_http do
+        RestClient::Resource.new(identity_providers_url(organization_id), @configuration.rest_client_options).get(headers)
+      end
+      JSON.parse(response).map { |idp_as_hash| IdentityProviderRepresentation.from_hash(idp_as_hash) }
+    end
+
+    def get_identity_provider(organization_id, identity_provider_alias)
+      raise ArgumentError.new("identity_provider_alias must be defined") if identity_provider_alias.nil?
+      response = execute_http do
+        RestClient::Resource.new("#{identity_providers_url(organization_id)}/#{identity_provider_alias}", @configuration.rest_client_options).get(headers)
+      end
+      IdentityProviderRepresentation.from_hash(JSON.parse(response))
+    end
+
+    def add_identity_provider(organization_id, identity_provider_alias)
+      raise ArgumentError.new("identity_provider_alias must be defined") if identity_provider_alias.nil?
+      execute_http do
+        RestClient::Resource.new(identity_providers_url(organization_id), @configuration.rest_client_options).post(identity_provider_alias, headers)
+      end
+      true
+    end
+
+    def delete_identity_provider(organization_id, identity_provider_alias)
+      execute_http do
+        RestClient::Resource.new(identity_provider_url(organization_id, identity_provider_alias), @configuration.rest_client_options).delete(headers)
+      end
+      true
+    end
+
+    def members_count(organization_id)
+      response = execute_http do
+        RestClient::Resource.new(members_count_url(organization_id), @configuration.rest_client_options).get(headers)
+      end
+      response.to_i
+    end
+
+    def members(organization_id, exact=nil, first=nil, max=nil, membership_type=nil, search=nil)
+      response = execute_http do
+        RestClient::Resource.new(members_url_with_query_parameters(organization_id, exact, first, max, membership_type, search), @configuration.rest_client_options).get(headers)
+      end
+      JSON.parse(response).map { |member_as_hash| MemberRepresentation.from_hash(member_as_hash) }
+    end
+
+    def invite_existing_user(organization_id, user_id)
+      raise ArgumentError.new("user_id must be defined") if user_id.nil?
+      execute_http do
+        RestClient::Resource.new(invite_existing_user_url(organization_id), @configuration.rest_client_options).post({id: user_id}, headers.merge(content_type: "application/x-www-form-urlencoded"))
+      end
+      true
+    end
+
+    def invite_user(organization_id, email, first_name, last_name)
+      execute_http do
+        RestClient::Resource.new(invite_user_url(organization_id), @configuration.rest_client_options).post({
+          email: email,
+          firstName: first_name,
+          lastName: last_name
+        }, headers.merge(content_type: "application/x-www-form-urlencoded"))
+      end
+      true
+    end
+
+    def add_member(organization_id, user_id)
+      raise ArgumentError.new("user_id must be defined") if user_id.nil?
+      execute_http do
+        RestClient::Resource.new(members_url(organization_id), @configuration.rest_client_options).post(user_id, headers)
+      end
+      true
+    end
+
+    def delete_member(organization_id, member_id)
+      execute_http do
+        RestClient::Resource.new(member_url(organization_id, member_id), @configuration.rest_client_options).delete(headers)
+      end
+      true
+    end
+
+    def get_member(organization_id, member_id)
+      response = execute_http do
+        RestClient::Resource.new(member_url(organization_id, member_id), @configuration.rest_client_options).get(headers)
+      end
+      MemberRepresentation.from_hash(JSON.parse(response))
+    end
+
+    def associated_with_member(member_id, brief_representation=true)
+      response = execute_http do
+        RestClient::Resource.new(associated_with_member_url(member_id, brief_representation), @configuration.rest_client_options).get(headers)
+      end
+      JSON.parse(response).map { |organization_as_hash| OrganizationRepresentation.from_hash(organization_as_hash) }
+    end
+
+    def organizations_url
+      "#{@realm_client.realm_admin_url}/organizations"
+    end
+
+    def organization_url(organization_id)
+      raise ArgumentError.new("organization_id must be defined") if organization_id.nil?
+      "#{organizations_url}/#{organization_id}"
+    end
+
+    def identity_providers_url(organization_id)
+      "#{organization_url(organization_id)}/identity-providers"
+    end
+
+    def identity_provider_url(organization_id, identity_provider_alias)
+      raise ArgumentError.new("identity_provider_alias must be defined") if identity_provider_alias.nil?
+      "#{identity_providers_url(organization_id)}/#{identity_provider_alias}"
+    end
+
+    def count_url(exact, query, search)
+      query_parameters = {exact: exact, q: query, search: search}.compact.to_a.map { |e| "#{e[0]}=#{e[1]}" }.join("&")
+      "#{organizations_url}/count?#{query_parameters}"
+    end
+
+    def organizations_url_with_parameters(brief_representation, exact, first, max, query, search)
+      query_parameters = {
+        briefRepresentation: brief_representation,
+        exact: exact,
+        first: first,
+        max: max,
+        q: query,
+        search: search
+      }.compact.to_a.map { |e| "#{e[0]}=#{e[1]}" }.join("&")
+      "#{organizations_url}?#{query_parameters}"
+    end
+
+    def associated_with_member_url(member_id, brief_representation=true)
+      "#{organizations_url}/members/#{member_id}/organizations?briefRepresentation=#{brief_representation}"
+    end
+
+    def members_count_url(organization_id)
+      "#{organization_url(organization_id)}/members/count"
+    end
+
+    def member_url(organization_id, member_id)
+      raise ArgumentError.new("member_id must be defined") if member_id.nil?
+      "#{organization_url(organization_id)}/members/#{member_id}"
+    end
+
+    def invite_existing_user_url(organization_id)
+      "#{organization_url(organization_id)}/members/invite-existing-user"
+    end
+
+    def invite_user_url(organization_id)
+      "#{organization_url(organization_id)}/members/invite-user"
+    end
+
+    def members_url(organization_id)
+      "#{organization_url(organization_id)}/members"
+    end
+
+    def members_url_with_query_parameters(organization_id, exact, first, max, membership_type, search)
+      query_parameters = {
+        exact: exact,
+        first: first,
+        max: max,
+        membershipType: membership_type,
+        search: search
+      }.compact.to_a.map { |e| "#{e[0]}=#{e[1]}" }.join("&")
+      "#{organization_url(organization_id)}/members?#{query_parameters}"
+    end
+
+    def build(name, alias_name, enabled, description, redirect_url=nil, domains=[], attributes={})
+      unless domains.is_a?(Array)
+        raise ArgumentError.new("domains must be an Array, got #{new_domains.class}")
+      end
+
+      unless domains.all? { |domain| domain.is_a?(KeycloakAdmin::OrganizationDomainRepresentation) }
+        raise ArgumentError.new("All items in domains must be of type OrganizationDomainRepresentation")
+      end
+
+      organization              = OrganizationRepresentation.new
+      organization.name         = name
+      organization.alias        = alias_name
+      organization.enabled      = enabled
+      organization.description  = description
+      organization.redirect_url = redirect_url
+      organization.domains      = domains
+      organization.attributes   = attributes
+      organization
+    end
+  end
+end