RubyGems - opensrs-ruby - Versions diffs - 0.1.0 - Mend

opensrs-ruby 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6fa12db38773abeaa598352a9c011222163f51fb764d9211011f2e9cdd0bd87f
+  data.tar.gz: de281c57faf8f23c228416cf9f3484713581f532d2020e2755e0564e831b3eb4
+SHA512:
+  metadata.gz: c3dd656f403f0d9312cd2531b97c63d431fab45e1839c3c8b3759e84b0da83fdd2ad79a35311392d773e426223d689d05c300af5a156c9697d7ec3e33a849b5d
+  data.tar.gz: d915f09dca9694ed8aa54d5f867ffd3db3be858b1036295680f41f9e7d5bdf1a443e6ac1477f672b8ffe45540fd45cfc13d2f3d64b2b250ac6076679cffd12cc

data/lib/opensrs/account.rb ADDED Viewed

@@ -0,0 +1,16 @@
+module OpenSRS
+  Balance = Struct.new(:amount, :hold, keyword_init: true)
+  module Account
+    module_function
+    def balance(client: OpenSRS.default_client)
+      result = client.call(action: "GET_BALANCE", object: "BALANCE")
+      attrs = result["attributes"]
+      Balance.new(
+        amount: attrs["balance"].to_f,
+        hold: attrs["hold_balance"].to_f
+      )
+    end
+  end
+end

data/lib/opensrs/client.rb ADDED Viewed

@@ -0,0 +1,174 @@
+require "net/http"
+require "uri"
+require "digest/md5"
+require "rexml/document"
+module OpenSRS
+  class Client
+    LIVE_URL = "https://rr-n1-tor.opensrs.net:55443"
+    TEST_URL = "https://horizon.opensrs.net:55443"
+    attr_reader :username
+    def initialize(username:, api_key:, test: false)
+      @username = username
+      @api_key = api_key
+      @url = test ? TEST_URL : LIVE_URL
+    end
+    def call(action:, object:, attributes: {}, extra: {})
+      xml = build_xml(action, object, attributes, extra)
+      response_body = post(xml)
+      result = parse_response(response_body)
+      check_for_errors!(result)
+      result
+    end
+    private
+    def post(xml)
+      signature = compute_signature(xml)
+      uri = URI(@url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.open_timeout = 15
+      http.read_timeout = 30
+      request = Net::HTTP::Post.new("/")
+      request["Content-Type"] = "text/xml"
+      request["X-Username"] = @username
+      request["X-Signature"] = signature
+      request.body = xml
+      http.request(request).body
+    rescue Net::OpenTimeout, Net::ReadTimeout, Errno::ECONNREFUSED, Errno::ECONNRESET => e
+      raise ConnectionError, e.message
+    end
+    def compute_signature(xml)
+      step1 = Digest::MD5.hexdigest(xml + @api_key)
+      Digest::MD5.hexdigest(step1 + @api_key)
+    end
+    def check_for_errors!(result)
+      return if result["is_success"] == "1"
+      code = result["response_code"]
+      message = result["response_text"]
+      case code
+      when "415"
+        raise AuthenticationError.new(message, code)
+      when "485"
+        raise InsufficientBalance.new(message, code)
+      when "211"
+        raise DomainUnavailable.new(message, code)
+      when "487"
+        raise TransferError.new(message, code)
+      when "410"
+        raise DomainNotFound.new(message, code)
+      else
+        raise RequestError.new(message, code)
+      end
+    end
+    def build_xml(action, object, attributes, extra)
+      items = [
+        item("protocol", "XCP"),
+        item("action", action),
+        item("object", object),
+      ]
+      extra.each { |k, v| items << item(k, v) }
+      items << item_assoc("attributes", attributes) unless attributes.empty?
+      <<~XML
+        <?xml version='1.0' encoding='UTF-8' standalone='no' ?>
+        <!DOCTYPE OPS_envelope SYSTEM 'ops.dtd'>
+        <OPS_envelope>
+          <header><version>0.9</version></header>
+          <body>
+            <data_block>
+              <dt_assoc>
+                #{items.join("\n              ")}
+              </dt_assoc>
+            </data_block>
+          </body>
+        </OPS_envelope>
+      XML
+    end
+    def item(key, value)
+      "<item key=\"#{key}\">#{escape(value)}</item>"
+    end
+    def item_assoc(key, hash)
+      inner = hash.map do |k, v|
+        if v.is_a?(Hash)
+          item_assoc(k, v)
+        elsif v.is_a?(Array)
+          item_array(k, v)
+        else
+          item(k, v)
+        end
+      end
+      "<item key=\"#{key}\"><dt_assoc>#{inner.join}</dt_assoc></item>"
+    end
+    def item_array(key, arr)
+      inner = arr.each_with_index.map do |v, i|
+        if v.is_a?(Hash)
+          item_assoc(i.to_s, v)
+        else
+          item(i.to_s, v)
+        end
+      end
+      "<item key=\"#{key}\"><dt_array>#{inner.join}</dt_array></item>"
+    end
+    def escape(val)
+      val.to_s.gsub("&", "&amp;").gsub("<", "&lt;").gsub(">", "&gt;")
+    end
+    def parse_response(xml_str)
+      doc = REXML::Document.new(xml_str)
+      root_assoc = doc.elements["//body/data_block/dt_assoc"]
+      parse_assoc(root_assoc)
+    end
+    def parse_assoc(element)
+      return {} unless element
+      result = {}
+      element.elements.each("item") do |el|
+        key = el.attributes["key"]
+        child_assoc = el.elements["dt_assoc"]
+        child_array = el.elements["dt_array"]
+        if child_assoc
+          result[key] = parse_assoc(child_assoc)
+        elsif child_array
+          result[key] = parse_array(child_array)
+        else
+          result[key] = el.text&.strip
+        end
+      end
+      result
+    end
+    def parse_array(element)
+      return [] unless element
+      items = {}
+      element.elements.each("item") do |el|
+        key = el.attributes["key"].to_i
+        child_assoc = el.elements["dt_assoc"]
+        child_array = el.elements["dt_array"]
+        if child_assoc
+          items[key] = parse_assoc(child_assoc)
+        elsif child_array
+          items[key] = parse_array(child_array)
+        else
+          items[key] = el.text&.strip
+        end
+      end
+      items.sort_by(&:first).map(&:last)
+    end
+  end
+end

data/lib/opensrs/contact.rb ADDED Viewed

@@ -0,0 +1,15 @@
+module OpenSRS
+  Contact = Struct.new(
+    :first_name, :last_name, :org_name, :address1, :address2,
+    :city, :state, :postal_code, :country, :phone, :email,
+    keyword_init: true
+  ) do
+    def self.from_hash(hash)
+      new(**hash.transform_keys(&:to_sym).slice(*members))
+    end
+    def to_api_hash
+      to_h.compact.transform_keys(&:to_s)
+    end
+  end
+end

data/lib/opensrs/domain.rb ADDED Viewed

@@ -0,0 +1,278 @@
+require "time"
+require "digest/md5"
+module OpenSRS
+  DomainCheck = Struct.new(:domain, :available, :price, keyword_init: true)
+  DomainSuggestion = Struct.new(:name, :available, keyword_init: true)
+  class Domain
+    attr_reader :name, :expires_at, :created_at, :updated_at, :nameservers, :contacts
+    def initialize(name:, client: nil, expires_at: nil, created_at: nil,
+                   updated_at: nil, auto_renew: false, locked: false,
+                   whois_private: false, nameservers: [], contacts: {})
+      @name = name
+      @client = client || OpenSRS.default_client
+      @expires_at = expires_at
+      @created_at = created_at
+      @updated_at = updated_at
+      @auto_renew = auto_renew
+      @locked = locked
+      @whois_private = whois_private
+      @nameservers = nameservers
+      @contacts = contacts
+    end
+    def auto_renew? = @auto_renew
+    def locked? = @locked
+    def whois_private? = @whois_private
+    class << self
+      def available?(domain_name, client: OpenSRS.default_client)
+        result = client.call(action: "LOOKUP", object: "DOMAIN",
+          attributes: { "domain" => domain_name })
+        result.dig("attributes", "status") == "available"
+      rescue OpenSRS::DomainUnavailable
+        false
+      end
+      def check(domain_name, client: OpenSRS.default_client)
+        lookup = client.call(action: "LOOKUP", object: "DOMAIN",
+          attributes: { "domain" => domain_name })
+        available = lookup.dig("attributes", "status") == "available"
+        price = nil
+        if available
+          price_result = client.call(action: "GET_PRICE", object: "DOMAIN",
+            attributes: { "domain" => domain_name, "period" => "1", "reg_type" => "new" })
+          price = price_result.dig("attributes", "price")&.to_f
+        end
+        price ||= lookup.dig("attributes", "price")&.to_f
+        DomainCheck.new(domain: domain_name, available: available, price: price)
+      rescue OpenSRS::DomainUnavailable
+        DomainCheck.new(domain: domain_name, available: false, price: nil)
+      end
+      def price(domain_name, period: 1, client: OpenSRS.default_client)
+        result = client.call(action: "GET_PRICE", object: "DOMAIN",
+          attributes: { "domain" => domain_name, "period" => period.to_s, "reg_type" => "new" })
+        result.dig("attributes", "price").to_f
+      end
+      def suggest(search_string, tlds: [".com", ".net", ".org", ".io"], client: OpenSRS.default_client)
+        result = client.call(action: "NAME_SUGGEST", object: "DOMAIN",
+          attributes: { "searchstring" => search_string, "tlds" => tlds, "max_wait_time" => "5" })
+        attrs = result["attributes"] || {}
+        suggestions = []
+        %w[lookup suggestion].each do |category|
+          items = attrs.dig(category, "items")
+          next unless items.is_a?(Array)
+          items.each do |item|
+            next unless item.is_a?(Hash) && item["domain"]
+            suggestions << DomainSuggestion.new(
+              name: item["domain"],
+              available: item["status"] == "available"
+            )
+          end
+        end
+        suggestions
+      end
+      def find(domain_name, client: OpenSRS.default_client)
+        result = client.call(action: "GET", object: "DOMAIN",
+          attributes: { "type" => "all_info" },
+          extra: { "domain" => domain_name })
+        attrs = result["attributes"] || {}
+        from_api(domain_name, attrs, client: client)
+      end
+      def all(from: "2020-01-01", to: "2030-12-31", client: OpenSRS.default_client)
+        result = client.call(action: "GET_DOMAINS_BY_EXPIREDATE", object: "DOMAIN",
+          attributes: { "exp_from" => from, "exp_to" => to, "limit" => "200", "page" => "0" })
+        domains = result.dig("attributes", "exp_domains") || []
+        domains.map do |d|
+          new(
+            name: d["name"],
+            expires_at: parse_time(d["expiredate"]),
+            client: client
+          )
+        end
+      end
+      def transferable?(domain_name, client: OpenSRS.default_client)
+        result = client.call(action: "CHECK_TRANSFER", object: "DOMAIN",
+          attributes: { "domain" => domain_name, "check_status" => "1" })
+        result.dig("attributes", "transferrable") == "1"
+      end
+      def register!(domain_name, period: 1, contacts:, nameservers:, client: OpenSRS.default_client)
+        contact_set = {}
+        contacts.each do |role, data|
+          c = data.is_a?(Contact) ? data : Contact.new(**data)
+          contact_set[role.to_s] = c.to_api_hash
+        end
+        %w[admin billing].each { |r| contact_set[r] ||= contact_set["owner"] }
+        ns_list = nameservers.each_with_index.map do |ns, i|
+          { "name" => ns, "sortorder" => (i + 1).to_s }
+        end
+        reg_user = domain_name.gsub(/[^a-z0-9]/i, "")[0, 20]
+        reg_pass = Digest::MD5.hexdigest(domain_name + Time.now.to_s)[0, 20]
+        client.call(action: "SW_REGISTER", object: "DOMAIN", attributes: {
+          "domain" => domain_name,
+          "reg_type" => "new",
+          "period" => period.to_s,
+          "reg_username" => reg_user,
+          "reg_password" => reg_pass,
+          "handle" => "process",
+          "custom_nameservers" => "1",
+          "custom_tech_contact" => "0",
+          "auto_renew" => "0",
+          "f_whois_privacy" => "1",
+          "contact_set" => contact_set,
+          "nameserver_list" => ns_list,
+        })
+        new(name: domain_name, client: client, nameservers: nameservers)
+      end
+      def transfer!(domain_name, auth_code:, contacts:, nameservers: [], client: OpenSRS.default_client)
+        contact_set = {}
+        contacts.each do |role, data|
+          c = data.is_a?(Contact) ? data : Contact.new(**data)
+          contact_set[role.to_s] = c.to_api_hash
+        end
+        %w[admin billing].each { |r| contact_set[r] ||= contact_set["owner"] }
+        reg_user = domain_name.gsub(/[^a-z0-9]/i, "")[0, 20]
+        reg_pass = Digest::MD5.hexdigest(domain_name + Time.now.to_s)[0, 20]
+        attrs = {
+          "domain" => domain_name,
+          "reg_type" => "transfer",
+          "period" => "1",
+          "reg_username" => reg_user,
+          "reg_password" => reg_pass,
+          "handle" => "process",
+          "custom_nameservers" => nameservers.any? ? "1" : "0",
+          "custom_tech_contact" => "0",
+          "auto_renew" => "0",
+          "contact_set" => contact_set,
+          "auth_info" => auth_code,
+        }
+        if nameservers.any?
+          attrs["nameserver_list"] = nameservers.each_with_index.map { |ns, i|
+            { "name" => ns, "sortorder" => (i + 1).to_s }
+          }
+        end
+        client.call(action: "SW_REGISTER", object: "DOMAIN", attributes: attrs)
+        new(name: domain_name, client: client, nameservers: nameservers)
+      end
+      private
+      def from_api(domain_name, attrs, client:)
+        nameservers = (attrs["nameserver_list"] || []).sort_by { |ns|
+          ns["sortorder"].to_i
+        }.map { |ns| ns["name"] }
+        contacts = {}
+        (attrs["contact_set"] || {}).each do |role, data|
+          contacts[role.to_sym] = Contact.from_hash(data) if data.is_a?(Hash)
+        end
+        new(
+          name: domain_name,
+          client: client,
+          expires_at: parse_time(attrs["registry_expiredate"] || attrs["expiredate"]),
+          created_at: parse_time(attrs["registry_createdate"]),
+          updated_at: parse_time(attrs["registry_updatedate"]),
+          auto_renew: attrs["auto_renew"].to_s == "1",
+          locked: attrs["f_lock_domain"].to_s == "1",
+          whois_private: attrs["whois_privacy_state"] == "enabled",
+          nameservers: nameservers,
+          contacts: contacts
+        )
+      end
+      def parse_time(str)
+        return nil unless str && !str.empty?
+        Time.parse(str)
+      end
+    end
+    def renew!(years: 1)
+      current = self.class.find(@name, client: @client)
+      expiry_year = current.expires_at&.year || Time.now.year
+      @client.call(action: "RENEW", object: "DOMAIN", attributes: {
+        "domain" => @name,
+        "auto_renew" => "0",
+        "handle" => "process",
+        "currentexpirationyear" => expiry_year.to_s,
+        "period" => years.to_s,
+      })
+    end
+    def lock!
+      modify_setting("f_lock_domain", "1")
+      @locked = true
+    end
+    def unlock!
+      modify_setting("f_lock_domain", "0")
+      @locked = false
+    end
+    def set_nameservers(nameservers)
+      ns_list = nameservers.each_with_index.map { |ns, i|
+        { "name" => ns, "sortorder" => (i + 1).to_s }
+      }
+      @client.call(action: "MODIFY", object: "DOMAIN",
+        attributes: {
+          "affect_domains" => "0",
+          "data" => "nameserver_list",
+          "assign_ns" => nameservers,
+          "nameserver_list" => ns_list
+        },
+        extra: { "domain" => @name })
+      @nameservers = nameservers
+    end
+    def enable_whois_privacy!
+      @client.call(action: "SET", object: "DOMAIN",
+        attributes: { "affect_domains" => "0", "data" => "whois_privacy_state", "state" => "enable" },
+        extra: { "domain" => @name })
+      @whois_private = true
+    end
+    def disable_whois_privacy!
+      @client.call(action: "SET", object: "DOMAIN",
+        attributes: { "affect_domains" => "0", "data" => "whois_privacy_state", "state" => "disable" },
+        extra: { "domain" => @name })
+      @whois_private = false
+    end
+    def set_auto_renew(enabled)
+      @client.call(action: "MODIFY", object: "DOMAIN",
+        attributes: { "affect_domains" => "0", "data" => "expire_action",
+                       "auto_renew" => enabled ? "1" : "0", "let_expire" => enabled ? "0" : "1" },
+        extra: { "domain" => @name })
+      @auto_renew = enabled
+    end
+    private
+    def modify_setting(key, value)
+      @client.call(action: "MODIFY", object: "DOMAIN",
+        attributes: { "affect_domains" => "0", "data" => "status", key => value },
+        extra: { "domain" => @name })
+    end
+  end
+end

data/lib/opensrs/errors.rb ADDED Viewed

@@ -0,0 +1,20 @@
+module OpenSRS
+  class Error < StandardError; end
+  class ConnectionError < Error; end
+  class RequestError < Error
+    attr_reader :response_code
+    def initialize(message = nil, response_code = nil)
+      @response_code = response_code
+      super(message)
+    end
+  end
+  class AuthenticationError < RequestError; end
+  class DomainNotFound < RequestError; end
+  class DomainUnavailable < RequestError; end
+  class TransferError < RequestError; end
+  class InsufficientBalance < RequestError; end
+end

data/lib/opensrs.rb ADDED Viewed

@@ -0,0 +1,19 @@
+require_relative "opensrs/errors"
+require_relative "opensrs/contact"
+require_relative "opensrs/client"
+require_relative "opensrs/account"
+require_relative "opensrs/domain"
+module OpenSRS
+  class << self
+    attr_reader :default_client
+    def configure(username:, api_key:, test: false)
+      @default_client = Client.new(username: username, api_key: api_key, test: test)
+    end
+    def reset!
+      @default_client = nil
+    end
+  end
+end

metadata ADDED Viewed

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: opensrs-ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- usiegj00
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+email:
+- 248302+usiegj00@users.noreply.github.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/opensrs.rb
+- lib/opensrs/account.rb
+- lib/opensrs/client.rb
+- lib/opensrs/contact.rb
+- lib/opensrs/domain.rb
+- lib/opensrs/errors.rb
+homepage: https://github.com/aluminumio/opensrs-gem
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Ruby client for the OpenSRS domain registration API
+test_files: []