casdoor-ruby-sdk 1.0.0 → 1.1.1

data/lib/casdoor/enforce.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  # The permission checks, the counterpart of enforce.go of the Go SDK. One of permission_id, model_id, resource_id,
+  # enforcer_id ("owner/name") or owner chooses the policies to check, the others are empty strings.
+  class Client
+    # casbin_request is a Casbin request like ["alice", "data1", "read"]. Returns true if any of the checked
+    # permissions allows it.
+    def enforce(permission_id, model_id, resource_id, enforcer_id, owner, casbin_request)
+      data = do_enforce('enforce', permission_id, model_id, resource_id, enforcer_id, owner, casbin_request)
+      raise ApiError, 'invalid data' unless data.is_a?(Array)
+
+      data.any?(true)
+    end
+
+    # casbin_requests is a list of Casbin requests. Returns the results of each checked permission, like
+    # [[true, false]] for two requests checked against one permission.
+    def batch_enforce(permission_id, model_id, resource_id, enforcer_id, owner, casbin_requests)
+      data = do_enforce('batch-enforce', permission_id, model_id, resource_id, enforcer_id, owner, casbin_requests)
+      raise ApiError, 'invalid data' unless data.is_a?(Array) && data.all?(Array)
+
+      data
+    end
+
+    private
+
+    def do_enforce(action, permission_id, model_id, resource_id, enforcer_id, owner, body)
+      query = { 'permissionId' => permission_id, 'modelId' => model_id, 'resourceId' => resource_id,
+                'enforcerId' => enforcer_id, 'owner' => owner }
+      do_post(action, query, body)['data']
+    end
+  end
+end

data/lib/casdoor/enforcer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  class Enforcer < Entity; end
+
+  # The enforcer APIs, the counterpart of enforcer.go of the Go SDK
+  class Client
+    def get_enforcers
+      get_objects('get-enforcers', Enforcer, 'owner' => organization_name)
+    end
+
+    # Returns the objects of the page and the total count. query_map can filter and sort them, e.g.
+    # { field: "name", value: "alice", sort_field: "created_time", sort_order: "descend" }
+    def get_pagination_enforcers(page, page_size, query_map = {})
+      get_pagination_objects('get-enforcers', Enforcer, organization_name, page, page_size, query_map)
+    end
+
+    def get_enforcer(name)
+      get_object('get-enforcer', Enforcer, 'id' => get_id(name))
+    end
+
+    def update_enforcer(enforcer)
+      modify_object('update-enforcer', Enforcer, enforcer, organization_name)
+    end
+
+    def add_enforcer(enforcer)
+      modify_object('add-enforcer', Enforcer, enforcer, organization_name)
+    end
+
+    def delete_enforcer(enforcer)
+      modify_object('delete-enforcer', Enforcer, enforcer, organization_name)
+    end
+  end
+end

data/lib/casdoor/entity.rb

@@ -17,9 +17,9 @@
 require 'json'
 
 module Casdoor
-  # An object of Casdoor, like a user or an application. It keeps all the JSON fields returned by Casdoor, so that
-  # updating an object never clears the fields that the SDK doesn't know about, and the fields added by newer
-  # Casdoor versions work without updating the SDK.
+  # An object of Casdoor, like a user or an application, the counterpart of the structs of the Go SDK. It keeps all
+  # the JSON fields returned by Casdoor, so that updating an object never clears the fields that the SDK doesn't know
+  # about, and the fields added by newer Casdoor versions work without updating the SDK.
   #
   # The fields can be read and written in snake_case, which is converted to the camelCase name used by Casdoor:
   #
@@ -38,6 +38,11 @@ module Casdoor
       key.to_s.gsub(/_([a-z\d])/) { Regexp.last_match(1).upcase }
     end
 
+    # The JSON name of a snake_case field name
+    def self.field_key(name)
+      camelize(name)
+    end
+
     def initialize(attributes = {})
       @attributes = {}
       (attributes || {}).each { |key, value| self[key] = value }
@@ -55,6 +60,11 @@ module Casdoor
       @attributes.key?(field_name(key))
     end
 
+    # "owner/name", the ID of the object in the Casdoor API
+    def get_id
+      "#{self[:owner]}/#{self[:name]}"
+    end
+
     def to_h
       @attributes.dup
     end
@@ -74,11 +84,11 @@ module Casdoor
     def method_missing(method_name, *args)
       field = method_name.to_s
       if field.end_with?('=') && args.length == 1
-        self[Entity.camelize(field.chomp('='))] = args.first
+        self[field.chomp('=').to_sym] = args.first
       elsif field.end_with?('?') && args.empty?
-        self[Entity.camelize(field.chomp('?'))] ? true : false
+        self[field.chomp('?').to_sym] ? true : false
       elsif args.empty? && field.match?(/\A[a-z][a-z\d_]*\z/)
-        self[Entity.camelize(field)]
+        self[method_name]
       else
         super
       end
@@ -92,44 +102,7 @@ module Casdoor
 
     # String keys are the exact names of Casdoor, while Symbol keys are snake_case
     def field_name(key)
-      key.is_a?(Symbol) ? Entity.camelize(key) : key.to_s
-    end
-  end
-
-  class Adapter < Entity; end
-  class Application < Entity; end
-  class Cert < Entity; end
-  class Enforcer < Entity; end
-  class Group < Entity; end
-  class Invitation < Entity; end
-  class Model < Entity; end
-  class Order < Entity; end
-  class Organization < Entity; end
-  class Payment < Entity; end
-  class Permission < Entity; end
-  class Plan < Entity; end
-  class Pricing < Entity; end
-  class Product < Entity; end
-  class Provider < Entity; end
-  class Resource < Entity; end
-  class Role < Entity; end
-  class Session < Entity; end
-  class Subscription < Entity; end
-  class Syncer < Entity; end
-  class Token < Entity; end
-  class Transaction < Entity; end
-  class User < Entity; end
-  class Webhook < Entity; end
-
-  # The claims of a JWT token issued by Casdoor: the fields of the user, plus the standard claims like "exp" and "aud"
-  class Claims < Entity
-    def user
-      User.new(to_h)
-    end
-
-    # Casdoor names the claim "tokenType", or "TokenType" for the "JWT-Custom" token format
-    def refresh_token?
-      (self['tokenType'] || self['TokenType']) == 'refresh-token'
+      key.is_a?(Symbol) ? self.class.field_key(key) : key.to_s
     end
   end
 end

data/lib/casdoor/global.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  # The counterpart of the *_global.go files of the Go SDK: every public method of Client can also be called on the
+  # module, with the global client initialized by Casdoor.init_config:
+  #
+  #   Casdoor.init_config(endpoint, client_id, client_secret, certificate, organization_name, application_name)
+  #   users = Casdoor.get_users
+  def self.global_client
+    @global_client or raise Error, 'The global client is not initialized, call Casdoor.init_config first'
+  end
+
+  (Client.public_instance_methods(false) - %i[endpoint client_id client_secret certificate organization_name
+                                              application_name access_token custom_headers custom_headers=
+                                              open_timeout open_timeout= read_timeout read_timeout=]).each do |method|
+    define_singleton_method(method) do |*args, **kwargs, &block|
+      global_client.public_send(method, *args, **kwargs, &block)
+    end
+  end
+end

data/lib/casdoor/group.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  class Group < Entity; end
+
+  # The group APIs, the counterpart of group.go of the Go SDK
+  class Client
+    def get_groups
+      get_objects('get-groups', Group, 'owner' => organization_name)
+    end
+
+    # Returns the objects of the page and the total count. query_map can filter and sort them, e.g.
+    # { field: "name", value: "alice", sort_field: "created_time", sort_order: "descend" }
+    def get_pagination_groups(page, page_size, query_map = {})
+      get_pagination_objects('get-groups', Group, organization_name, page, page_size, query_map)
+    end
+
+    def get_group(name)
+      get_object('get-group', Group, 'id' => get_id(name))
+    end
+
+    def update_group(group)
+      modify_object('update-group', Group, group, organization_name)
+    end
+
+    def add_group(group)
+      modify_object('add-group', Group, group, organization_name)
+    end
+
+    def delete_group(group)
+      modify_object('delete-group', Group, group, organization_name)
+    end
+  end
+end

data/lib/casdoor/invitation.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  class Invitation < Entity; end
+
+  # The invitation APIs, the counterpart of invitation.go of the Go SDK
+  class Client
+    def get_invitations
+      get_objects('get-invitations', Invitation, 'owner' => organization_name)
+    end
+
+    # Returns the objects of the page and the total count. query_map can filter and sort them, e.g.
+    # { field: "name", value: "alice", sort_field: "created_time", sort_order: "descend" }
+    def get_pagination_invitations(page, page_size, query_map = {})
+      get_pagination_objects('get-invitations', Invitation, organization_name, page, page_size, query_map)
+    end
+
+    def get_invitation(name)
+      get_object('get-invitation', Invitation, 'id' => get_id(name))
+    end
+
+    # The invitation of the code, for the application (in "admin") that the user signs up with
+    def get_invitation_info(code, application_name)
+      get_object('get-invitation-info', Invitation, 'applicationId' => "admin/#{application_name}", 'code' => code)
+    end
+
+    def update_invitation(invitation)
+      modify_object('update-invitation', Invitation, invitation, organization_name)
+    end
+
+    def update_invitation_for_columns(invitation, columns)
+      modify_object('update-invitation', Invitation, invitation, organization_name, columns)
+    end
+
+    def add_invitation(invitation)
+      modify_object('add-invitation', Invitation, invitation, organization_name)
+    end
+
+    def delete_invitation(invitation)
+      modify_object('delete-invitation', Invitation, invitation, organization_name)
+    end
+  end
+end

data/lib/casdoor/jwt.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'jwt'
+require 'openssl'
+
+module Casdoor
+  # The claims of a JWT token issued by Casdoor: the fields of the user, plus the standard claims like "exp" and "aud"
+  class Claims < Entity
+    def user
+      User.new(to_h)
+    end
+
+    # Casdoor names the claim "tokenType" for the JWT, JWT-Empty and JWT-Standard formats, and "TokenType" for
+    # JWT-Custom
+    def refresh_token?
+      (self['tokenType'] || self['TokenType']) == 'refresh-token'
+    end
+  end
+
+  # Verifying the JWT tokens, the counterpart of jwt.go of the Go SDK
+  class Client
+    JWT_ALGORITHMS = %w[RS256 RS384 RS512 ES256 ES384 ES512 PS256 PS384 PS512].freeze
+
+    # Verifies a JWT token (the access token or the ID token) with the certificate of the client, and returns its
+    # claims. The token must not be expired, and must be issued to this application: pass audience: to check a
+    # different audience (e.g. the resource of RFC 8707), or audience: false to skip the check.
+    #
+    #   claims = client.parse_jwt_token(token["access_token"])
+    #   claims.name          # => "alice"
+    #   claims.owner         # => "casbin"
+    #   claims.user          # => Casdoor::User
+    def parse_jwt_token(token, audience: nil)
+      # The expiration and the "not before" time are verified by default
+      payload, = JWT.decode(token, jwt_public_key, true, algorithms: JWT_ALGORITHMS)
+      check_audience(payload['aud'], audience) unless audience == false
+      Claims.new(payload)
+    rescue JWT::DecodeError => e
+      raise InvalidTokenError, e.message
+    end
+
+    private
+
+    def jwt_public_key
+      pem = certificate.to_s
+      raise Error, 'The certificate of the client is required to parse JWT tokens' if pem.strip.empty?
+
+      pem.include?('CERTIFICATE') ? OpenSSL::X509::Certificate.new(pem).public_key : OpenSSL::PKey.read(pem)
+    end
+
+    # Casdoor issues the tokens to the client ID, or to "<client ID>-org-<organization>" for shared applications
+    def check_audience(aud, audience)
+      auds = Array(aud)
+      valid = if audience
+                auds.include?(audience)
+              else
+                auds.any? { |item| item == client_id || item.to_s.start_with?("#{client_id}-org-") }
+              end
+      raise InvalidTokenError, "The token is issued to #{auds.inspect}, not this application" unless valid
+    end
+  end
+end

data/lib/casdoor/ldap.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  # An LDAP server of an organization. Unlike the other objects, it's identified by "owner/id" instead of
+  # "owner/name".
+  class Ldap < Entity
+    def get_id
+      "#{self[:owner]}/#{self[:id]}"
+    end
+  end
+
+  class LdapUser < Entity; end
+
+  # The LDAP APIs, the counterpart of ldap.go of the Go SDK
+  class Client
+    def get_ldaps
+      get_objects('get-ldaps', Ldap, 'owner' => organization_name)
+    end
+
+    def get_ldap(id)
+      get_object('get-ldap', Ldap, 'id' => get_id(id))
+    end
+
+    def add_ldap(ldap)
+      modify_object('add-ldap', Ldap, ldap, organization_name)
+    end
+
+    def delete_ldap(ldap)
+      modify_object('delete-ldap', Ldap, ldap, organization_name)
+    end
+
+    def update_ldap(ldap)
+      modify_object('update-ldap', Ldap, ldap, organization_name)
+    end
+
+    # The users in the LDAP server. Returns a hash like {"users" => [LdapUser], "existUuids" => [...]}.
+    def get_ldap_users(id)
+      data = do_get_bytes(get_url('get-ldap-users', 'id' => get_id(id))) || {}
+      data.merge('users' => (data['users'] || []).map { |user| LdapUser.new(user) })
+    end
+
+    # Imports the LDAP users into Casdoor. Returns a hash like {"exist" => [LdapUser], "failed" => [LdapUser]}.
+    def sync_ldap_users(id, users)
+      data = do_post('sync-ldap-users', { 'id' => get_id(id) }, users.map { |user| to_entity(LdapUser, user) })['data']
+      (data || {}).to_h { |key, value| [key, (value || []).map { |user| LdapUser.new(user) }] }
+    end
+
+    # Imports all the users of the LDAP server into Casdoor
+    def sync_ldap_users_from_server(id)
+      sync_ldap_users(id, get_ldap_users(id)['users'])
+    end
+  end
+end

data/lib/casdoor/logout.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  # Signing users out, the counterpart of logout.go of the Go SDK
+  class Client
+    # Signs the user out of all their sessions, and expires their tokens
+    def logout(access_token)
+      sso_logout(access_token, true)
+    end
+
+    # Signs the user out of only the session of the access token
+    def logout_current_session(access_token)
+      sso_logout(access_token, false)
+    end
+
+    private
+
+    # The "/api/sso-logout" API identifies the user by their own access token, so the Bearer token is used instead of
+    # the application's Basic Auth
+    def sso_logout(access_token, logout_all)
+      raise ArgumentError, 'logout() error: the access_token should not be empty' if access_token.to_s.empty?
+
+      with_access_token(access_token).do_post('sso-logout', { 'logoutAll' => logout_all.to_s }, nil, true)
+      true
+    end
+  end
+end

data/lib/casdoor/mfa.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  # Setting up the multi-factor authentication of a user, the counterpart of mfa.go of the Go SDK. mfa_type is
+  # "app" (TOTP), "sms" or "email". The responses are the hashes of Casdoor, like
+  # {"status" => "ok", "msg" => "", "data" => ...}.
+  class Client
+    # Starts setting up the MFA. For "app", the "data" has the "secret", the "url" of the QR code and the
+    # "recoveryCodes".
+    def initiate(owner, mfa_type, name)
+      do_post('mfa/setup/initiate', nil, { 'owner' => owner, 'mfaType' => mfa_type, 'name' => name }, true)
+    end
+
+    # Verifies the passcode of the MFA being set up
+    def verify(owner, mfa_type, name, secret, passcode)
+      form = { 'owner' => owner, 'mfaType' => mfa_type, 'name' => name, 'secret' => secret, 'passcode' => passcode }
+      do_post('mfa/setup/verify', nil, form, true)
+    end
+
+    # Enables the MFA after it's verified
+    def enable(owner, mfa_type, name, secret, recovery_code)
+      form = { 'owner' => owner, 'mfaType' => mfa_type, 'name' => name, 'secret' => secret,
+               'recoveryCodes' => recovery_code }
+      do_post('mfa/setup/enable', nil, form.reject { |_, value| value.to_s.empty? }, true)
+    end
+
+    def set_preferred(owner, mfa_type, name, secret)
+      form = { 'owner' => owner, 'mfaType' => mfa_type, 'name' => name, 'secret' => secret }
+      do_post('set-preferred-mfa', nil, form.reject { |_, value| value.to_s.empty? }, true)
+      true
+    end
+
+    # Disables all the MFA of the user
+    def delete(owner, name)
+      do_post('delete-mfa', { 'owner' => owner, 'name' => name }, nil)
+      true
+    end
+  end
+end

data/lib/casdoor/model.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  class Model < Entity; end
+
+  # The model APIs, the counterpart of model.go of the Go SDK
+  class Client
+    def get_models
+      get_objects('get-models', Model, 'owner' => organization_name)
+    end
+
+    # Returns the objects of the page and the total count. query_map can filter and sort them, e.g.
+    # { field: "name", value: "alice", sort_field: "created_time", sort_order: "descend" }
+    def get_pagination_models(page, page_size, query_map = {})
+      get_pagination_objects('get-models', Model, organization_name, page, page_size, query_map)
+    end
+
+    def get_model(name)
+      get_object('get-model', Model, 'id' => get_id(name))
+    end
+
+    def update_model(model)
+      modify_object('update-model', Model, model, organization_name)
+    end
+
+    def add_model(model)
+      modify_object('add-model', Model, model, organization_name)
+    end
+
+    def delete_model(model)
+      modify_object('delete-model', Model, model, organization_name)
+    end
+  end
+end

data/lib/casdoor/notification.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Copyright 2026 The Casdoor Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Casdoor
+  # Sending notifications with the notification provider of the application, the counterpart of notification.go of
+  # the Go SDK
+  class Client
+    # recipient can be empty for the providers that send to a fixed channel
+    def send_notification(content, recipient = '')
+      form = { 'content' => content }
+      form['recipient'] = recipient unless recipient.to_s.empty?
+      do_post('send-notification', nil, form)
+      true
+    end
+  end
+end