peasys-ruby 1.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a2bfe718a25db8bdd2f49fa52d98d431b72bcc7615a8228b39e57d8e92b3d587
+  data.tar.gz: 896d7f841636adec7f73a3b3f32beb5ede86267c27622b825d9c4acf9464d3e0
+SHA512:
+  metadata.gz: 0fb9b7343f3fdf459aff902176db299311b6d88a23457ac0fc1c88821cf3a716364d3eaf0fb82da1066b53972679450d053ecc32f3969d0bc3ec77a2dafcd9c1
+  data.tar.gz: 2a8c6efd843b885428da0fa402f4d0b8bded3234a19700b26ea132429cef0169ac21f1f7fb0e830300bd8c8c8614b4c7e4f0ad0beebfd812c33bb3680fc9fab4

data/lib/pea_client.rb

@@ -0,0 +1,478 @@
+require 'socket'
+require 'json'
+require 'uri'
+require 'net/http'
+
+class PeaClient
+    @@end_pack = "dipsjbiemg"
+
+    ##
+    # Initialize a new instance of the PeaClient class. Initiates a connexion with the AS/400 server.
+    #
+    # Params:
+    # +partition_name+:: DNS name (name of the partition) of the remote AS/400 server.
+    # +port+:: Port used for the data exchange between the client and the server.
+    # +username+:: Username of the AS/400 profile used for connexion.
+    # +password+:: Password of the AS/400 profile used for connexion.
+    # +id_client+:: ID of the client account on the DIPS website.
+    # +online_version+:: Set to true if you want to use the online version of Peasys (<see cref="https://dips400.com/docs/connexion"/>).
+    # +retrieve_statistics+:: Set to true if you want the statistics of the license key use to be collect.
+    #
+    # raises a PeaInvalidCredentialsError if credentials are empty.
+    # raises a PeaConnexionError if an error occured during the connexion process.
+    # raises a PeaInvalidCredentialsError if IBMi credentials are invalid.
+
+    def initialize(ip_adress, partition_name, port, username, password, id_client, online_version, retrieve_statistics)
+
+        if ip_adress.empty? || username.empty? || password.empty?
+            raise PeaInvalidCredentialsError.new("Parameters of the PeaClient should not be either null or empty")
+        end
+
+        @ip_adress = ip_adress
+        @id_client = id_client
+        @partition_name = partition_name
+        @username = username
+        @password = password
+        @port = port
+        @online_version = online_version
+        @retrieve_statistics = retrieve_statistics
+        @connexion_status = "ds"
+        @connexion_message = "ds"
+
+        token = "xqdsg27010wmca6052009050000000IDSP1tiupozxreybjhlk"
+        if online_version
+            begin
+                uri = URI("https://dips400.com/api/license-key/retrieve-token/#{partition_name}/#{id_client}")
+                res = Net::HTTP.get_response(uri)
+
+                data = JSON.parse(res.body)
+                token = data["token"]
+                is_valid = data["isValid"]
+
+                if not(is_valid)
+                    raise PeaInvalidLicenseKeyError.new("Your subscription is not valid, visit https://dips400.com/account/subscriptions for more information.")
+                end
+
+            rescue PeaInvalidLicenseKeyError => e
+                raise e
+            rescue StandardError => error
+                # If dips400.com doesn't respond, let's try an affline verification with the offline token
+            end
+        end
+        
+        begin
+            @tcp_client = TCPSocket.new ip_adress, port
+        rescue => error
+            raise PeaConnexionError.new(error.full_message)
+        else
+            login = username.ljust(10, " ") + token.ljust(50, " ") + password
+            @tcp_client.send(login, 0)
+            @connexion_status = @tcp_client.read(1)
+
+            case @connexion_status
+            when "1"
+                @connexion_message = "Connected"
+                @connexion_status = 1
+            when "2"
+                @connexion_message = "Unable to set profile, check profile validity."
+                @connexion_status = 2
+                raise PeaConnexionError.new("Unable to set profile, check profile validity.")
+            when "3"
+                @connexion_message = "Invalid credential"
+                @connexion_status = 1
+                raise PeaInvalidCredentialsError.new("Invalid userName or password, check again")
+            when "B"
+                @connexion_message = "Peasys Online : your token connexion is no longer valid, retry to connect."
+                @connexion_status = 5
+                raise PeaConnexionError.new("Peasys Online : your token connexion is no longer valid, retry to connect.")
+            when "D"
+                @connexion_message = "Peasys Online : the partition name you provided doesn't match the actual name of the machine."
+                @connexion_status = 6
+                raise PeaConnexionError.new("Peasys Online : the partition name you provided doesn't match the actual name of the machine.")
+            when "E"
+                @connexion_message = "You reached the max number of simultaneously connected peasys users for that partition and license key. Contact us for upgrading your license."
+                @connexion_status = 7
+                raise PeaConnexionError.new("You reached the max number of simultaneously connected peasys users for that partition and license key. Contact us for upgrading your license.")
+            when "F"
+                @connexion_message = "Your license is no longer valid. Subscribe to another license in order to continue using Peasys."
+                @connexion_status = 8
+                raise PeaConnexionError.new("Your license is no longer valid. Subscribe to another license in order to continue using Peasys.")
+            when "0" , "A" , "C" , "G"
+                @connexion_message = "Error linked to DIPS source code. Please, contact us immediatly to fix the issue."
+                @connexion_status = -1
+                raise PeaConnexionError.new("Error linked to DIPS source code. Please, contact us immediatly to fix the issue.")
+            else
+                raise PeaConnexionError.new("Exception during connexion process, contact us for more informations")
+            end
+        end
+    end
+
+    ##
+    # Sends the SELECT SQL query to the server that execute it and retrieve the desired data.
+    #
+    # Params:
+    # +query+:: SQL query that should start with the SELECT keyword.
+    #
+    # raises a PeaInvalidSyntaxQueryError if query is empty or doesn't start with SELECT.
+
+    def execute_select(query)
+        if query.empty?
+            raise PeaInvalidSyntaxQueryError.new("Query should not be either null or empty")
+        end
+        if !query.upcase.start_with?("SELECT")
+            raise PeaInvalidSyntaxQueryError.new("Query should start with the SELECT SQL keyword")
+        end
+
+        result, list_name, nb_row, sql_state, sql_message = build_data(query)
+        
+        return PeaSelectResponse.new(sql_message.eql?("00000"), sql_message, sql_state, result, nb_row, list_name)
+    end
+
+    ##
+    # Sends the UPDATE SQL query to the server that execute it and retrieve the desired data.
+    #
+    # Params:
+    # +query+:: SQL query that should start with the UPDATE keyword.
+    #
+    # raises a PeaInvalidSyntaxQueryError if query is empty or doesn't start with UPDATE.
+
+    def execute_update(query)
+        if query.empty?
+            raise PeaInvalidSyntaxQueryError.new("Query should not be either null or empty")
+        end
+        if !query.upcase.start_with?("UPDATE")
+            raise PeaInvalidSyntaxQueryError.new("Query should start with the UPDATE SQL keyword")
+        end
+
+        nb_row, sql_state, sql_message = modify_table(query)
+        has_succeeded = sql_state.eql?("00000") || sql_state.eql?("01504")
+        
+        return PeaUpdateResponse.new(has_succeeded, sql_message, sql_state, nb_row)
+    end
+
+    ##
+    # Sends the CREATE SQL query to the server that execute it and retrieve the desired data.
+    #
+    # Params:
+    # +query+:: SQL query that should start with the CREATE keyword.
+    #
+    # raises a PeaInvalidSyntaxQueryError if query is empty or doesn't start with CREATE.
+
+    def execute_create(query)
+        if query.empty?
+            raise PeaInvalidSyntaxQueryError.new("Query should not be either null or empty")
+        end
+        if !query.upcase.start_with?("CREATE")
+            raise PeaInvalidSyntaxQueryError.new("Query should start with the CREATE SQL keyword")
+        end
+
+        nb_row, sql_state, sql_message = modify_table(query)
+
+        query_words = query.split(' ')
+        tb_schema = Hash.new()
+        if query_words[1].upcase.eql?("TABLE") 
+            names = query_words[2].split('/')
+            tb_query = """SELECT COLUMN_NAME, ORDINAL_POSITION, DATA_TYPE, LENGTH, NUMERIC_SCALE, IS_NULLABLE, IS_UPDATABLE, NUMERIC_PRECISION FROM 
+            QSYS2.SYSCOLUMNS WHERE SYSTEM_TABLE_NAME = '""" + names[1].upcase + "' AND SYSTEM_TABLE_SCHEMA = '" + names[0].upcase + "'"
+
+            result, list_name, nb_row, sql_state, sql_message = build_data(tb_query)
+
+            for i in 0..(nb_row - 1) do
+                tb_schema["column_name"] = ColumnInfo.new(result["COLUMN_NAME"][i], result["ORDINAL_POSITION"][i], result["DATA_TYPE"][i], result["LENGTH"][i], 
+                    result["NUMERIC_SCALE"][i], result["IS_NULLABLE"][i], result["IS_UPDATABLE"][i], result["NUMERIC_PRECISION"][i])
+            end
+        end
+
+        case query_words[1].upcase
+        when "TABLE"
+            return PeaCreateResponse.new(sql_message.eql?("00000"), sql_message, sql_state, "", "", tb_schema)
+        when "INDEX"
+            return PeaCreateResponse.new(sql_message.eql?("00000"), sql_message, sql_state, "", query_words[2], "")
+        when "DATABASE"
+            return PeaCreateResponse.new(sql_message.eql?("00000"), sql_message, sql_state, query_words[2], "", "")
+        else
+            raise PeaConnexionError.new("Exception during connexion process, contact us for more informations")
+        end
+    end
+    
+    ##
+    # Sends the DELETE SQL query to the server that execute it and retrieve the desired data.
+    #
+    # Params:
+    # +query+:: SQL query that should start with the DELETE keyword.
+    #
+    # raises a PeaInvalidSyntaxQueryError if query is empty or doesn't start with DELETE.
+
+    def execute_delete(query)
+        if query.empty?
+            raise PeaInvalidSyntaxQueryError.new("Query should not be either null or empty")
+        end
+        if !query.upcase.start_with?("DELETE")
+            raise PeaInvalidSyntaxQueryError.new("Query should start with the DELETE SQL keyword")
+        end
+
+        nb_row, sql_state, sql_message = modify_table(query)
+        
+        return PeaDeleteResponse.new(sql_message.eql?("00000"), sql_message, sql_state, nb_row)
+    end
+    
+    ##
+    # Sends the ALTER SQL query to the server that execute it and retrieve the desired data.
+    #
+    # Params:
+    # +query+:: SQL query that should start with the ALTER keyword.
+    #
+    # raises a PeaInvalidSyntaxQueryError if query is empty or doesn't start with ALTER.
+
+    def execute_alter(query, retrieve_table_schema)
+        if query.empty?
+            raise PeaInvalidSyntaxQueryError.new("Query should not be either null or empty")
+        end
+        if !query.upcase.start_with?("ALTER")
+            raise PeaInvalidSyntaxQueryError.new("Query should start with the ALTER SQL keyword")
+        end
+
+        nb_row, sql_state, sql_message = modify_table(query)
+
+        tb_schema = Hash.new()
+        if retrieve_table_schema
+            query_words = query.split(' ')
+            names = query_words[2].split('/')
+            tb_query = """SELECT COLUMN_NAME, ORDINAL_POSITION, DATA_TYPE, LENGTH, NUMERIC_SCALE, IS_NULLABLE, IS_UPDATABLE, NUMERIC_PRECISION FROM 
+            QSYS2.SYSCOLUMNS WHERE SYSTEM_TABLE_NAME = '""" + names[1].upcase + "' AND SYSTEM_TABLE_SCHEMA = '" + names[0].upcase + "'"
+
+            result, list_name, nb_row, sql_state, sql_message = build_data(tb_query)
+
+            for i in 0..(nb_row - 1) do
+                tb_schema["column_name"] = ColumnInfo.new(result["COLUMN_NAME"][i], result["ORDINAL_POSITION"][i], result["DATA_TYPE"][i], result["LENGTH"][i], 
+                    result["NUMERIC_SCALE"][i], result["IS_NULLABLE"][i], result["IS_UPDATABLE"][i], result["NUMERIC_PRECISION"][i])
+            end
+        end
+        
+        return PeaAlterResponse.new(sql_message.eql?("00000"), sql_message, sql_state, tb_schema)
+    end
+
+    ##
+    # Sends the DROP SQL query to the server that execute it and retrieve the desired data.
+    #
+    # Params:
+    # +query+:: SQL query that should start with the DROP keyword.
+    #
+    # raises a PeaInvalidSyntaxQueryError if query is empty or doesn't start with DROP.
+
+    def execute_drop(query)
+        if query.empty?
+            raise PeaInvalidSyntaxQueryError.new("Query should not be either null or empty")
+        end
+        if !query.upcase.start_with?("DROP")
+            raise PeaInvalidSyntaxQueryError.new("Query should start with the DROP SQL keyword")
+        end
+
+        nb_row, sql_state, sql_message = modify_table(query)
+        
+        return PeaDropResponse.new(sql_message.eql?("00000"), sql_message, sql_state)
+    end
+
+    ##
+    # Sends the INSERT SQL query to the server that execute it and retrieve the desired data.
+    #
+    # Params:
+    # +query+:: SQL query that should start with the INSERT keyword.
+    #
+    # raises a PeaInvalidSyntaxQueryError if query is empty or doesn't start with INSERT.
+
+    def execute_insert(query)
+        if query.empty?
+            raise PeaInvalidSyntaxQueryError.new("Query should not be either null or empty")
+        end
+        if !query.upcase.start_with?("INSERT")
+            raise PeaInvalidSyntaxQueryError.new("Query should start with the INSERT SQL keyword")
+        end
+
+        nb_row, sql_state, sql_message = modify_table(query)
+        
+        return PeaInsertResponse.new(sql_message.eql?("00000"), sql_message, sql_state, nb_row)
+    end
+
+    ##
+    # Sends the SQL query to the server that execute it and retrieve the desired data.
+    #
+    # Params:
+    # +query+:: SQL query.
+    #
+    # raises a PeaInvalidSyntaxQueryError if query is empty.
+
+    def execute_sql(query)
+        if query.empty?
+            raise PeaInvalidSyntaxQueryError.new("Query should not be either null or empty")
+        end
+
+        nb_row, sql_state, sql_message = modify_table(query)
+        
+        return PeaResponse.new(sql_message.eql?("00000"), sql_message, sql_state)
+    end
+
+    ##
+    # Sends a OS/400 command to the server and retreives the potential warning messages.
+    #
+    # Params:
+    # +command+:: The command that will be sent to the server.
+
+    def execute_command(command)
+        data = retrieve_data("exas" + command + @@end_pack)
+        description_offset = 112
+        result = Array.new()
+
+        /C[A-Z]{2}[0-9]{4}/.match(data) do |m|
+            
+            if !m[0].start_with?("CPI") && m.offset(0)[0] + description_offset < data.length
+                description = data[m.offset(0)[0] + description_offset..(data.length - (m.offset(0)[0] + description_offset))]
+                description = description[0..description.index(".")]
+                description = description.gsub(/[^a-zA-Z0-9 ._'*:-]/, '')
+            end
+
+            result.append(m[0] + " " + description)
+
+        end
+        return PeaCommandResponse.new(result)
+    end
+
+    ##
+    # Closes the TCP connexion with the server.
+
+    def disconnect()
+        @tcp_client.send("stopdipsjbiemg", 0)
+        @tcp_client.close()
+    end
+
+    def id_client
+        @id_client
+    end
+
+    def  partition_name
+        @partition_name
+    end
+
+    def username
+        @username
+    end
+
+    def port
+        @port
+    end
+
+    def online_version
+        @online_version
+    end
+
+    def retrieve_statistics
+        @retrieve_statistics
+    end
+
+    def connexion_status
+        @connexion_status
+    end
+
+    def connexion_message
+        @connexion_message
+    end
+
+    private
+    
+    def build_data(query)
+        header = retrieve_data("geth" + query + @@end_pack)
+        sql_state = "00000"
+        sql_message = "SELECT correctly executed"
+
+        begin
+            header_data = JSON.parse(header)
+        rescue
+            sql_state = header[1..5];
+            sql_message = header[6..];
+        else
+            list_name = Array.new()
+            list_type = Array.new()
+            list_prec = Array.new()
+            list_scal = Array.new();
+        
+            header_data.each do |item|
+                list_name = list_name.append(item["name"].strip)
+                list_type = list_type.append(item["type"].to_i)
+                list_prec = list_prec.append(item["prec"].to_i)
+                list_scal = list_scal.append(item["scal"].to_i)
+            end
+        end
+
+        nb_col = list_name.length
+        sum_precision = 0
+        result = Hash.new()
+        list_prec.each_index do |i|
+            sum_precision += list_prec[i]
+            result[list_name[i]] = Array.new()
+        end
+
+        data = retrieve_data("getd" + query + @@end_pack)
+
+        # sends statistics
+
+        nb_row = data.length / sum_precision;
+        pointer = 0;
+        while pointer != data.length
+            for m in 0..(nb_col - 1) do
+                scale = list_scal[m]
+                precision = list_prec[m]
+                type = list_type[m]
+                name = list_name[m]
+                
+                if ((type == 484 && scale != 0) || (type == 485 && scale != 0) || (type == 488 && scale != 0) || (type == 489 && scale != 0)) # numeric packed
+                    temp_float_data = data[pointer..(pointer + precision - 1)].to_f / 10 ** scale
+                    pointer += precision;
+                    result[name].append(temp_float_data.to_s);
+                elsif (type == 492 || type == 493) # long
+                    result[name].append(data[pointer..(pointer + 20 - 1)].strip);
+                    pointer += 20;
+                elsif (type == 496 || type == 497) # int
+                    result[name].append(data[pointer..(pointer + 10 - 1)].strip);
+                    pointer += 10;
+                elsif (type == 500 || type == 501) # short
+                    result[name].append(data[pointer..(pointer + 5 - 1)].strip);
+                    pointer += 5;
+                else # string, date, time, timestamp
+                    result[name].append(data[pointer..(pointer + precision - 1)].strip);
+                    pointer += precision;
+                end
+            end
+        end
+        return result, list_name, nb_row, sql_state, sql_message
+    end
+
+    def modify_table(query)
+        header = retrieve_data("updt" + query + @@end_pack)
+        sql_state = header[1..5]
+        sql_message = header[6..]
+
+        # retrieve stats
+
+        row_count = 0
+        if query.upcase.start_with?("INSERT") || query.upcase.start_with?("UPDATE") || query.upcase.start_with?("DELETE")
+            row_count = sql_state.eql?("00000") ? sql_message[..1].to_i : 0
+        end
+
+        return row_count, sql_state, sql_message 
+    end
+    
+    def retrieve_data(command)
+        
+        @tcp_client.send(command, 0)
+
+        data = ""
+        if command.start_with?("geth") || command.start_with?("updt")
+            data += "["
+        end
+
+        while data.length < @@end_pack.length || data[(data.length - @@end_pack.length)..(data.length-1)] != @@end_pack
+            data += @tcp_client.read(1)
+        end
+        return data[0..(data.length - (@@end_pack.length + 1))]
+    end
+end

data/lib/pea_exception.rb

@@ -0,0 +1,31 @@
+
+class PeaError < StandardError
+
+    ##
+    # Abstract the concept of exception encountered during the manipulation of the Peasys library
+    #
+    # Params:
+    # +msg+:: The message describing the error.
+
+    def initialize(msg="Error coming from the Peasys library")
+        super(msg)
+    end
+end
+
+class PeaConnexionError < PeaError
+end
+
+class PeaInvalidCredentialsError < PeaConnexionError
+end
+
+class PeaInvalidLicenseKeyError < PeaConnexionError
+end
+
+class PeaQueryerror < PeaError
+end
+
+class PeaInvalidSyntaxQueryError < PeaQueryerror
+end
+
+class PeaUnsupportedOperationError < PeaQueryerror
+end

data/lib/pea_response.rb

@@ -0,0 +1,300 @@
+# Abstracts the concept of response in the case of a query executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaResponse
+
+    ##
+    # Initialize a new instance of the PeaResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the query has correctly been executed. Set to true if the SQL state is 00000.
+    # +sql_message+:: SQL message return from the execution of the query.
+    # +sql_state+:: SQL state return from the execution of the query.
+
+    def initialize(has_succeeded, sql_message, sql_state)
+        @has_succeeded = has_succeeded
+        @sql_message = sql_message
+        @sql_state = sql_state
+    end
+
+    def has_succeeded
+        @has_succeeded
+    end
+
+    def sql_message
+        @sql_message
+    end
+
+    def sql_state
+        @sql_state
+    end
+end
+
+# Represents the concept of response in the case of a CREATE query executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaCreateResponse < PeaResponse
+
+    ##
+    # Initialize a new instance of the PeaCreateResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the query has correctly been executed. Set to true if the SQL state is 00000.
+    # +sql_message+:: SQL message return from the execution of the query.
+    # +sql_state+:: SQL state return from the execution of the query.
+    # +database_name+:: Name of the database if the SQL create query creates a new database.
+    # +index_name+:: Name of the index if the SQL create query creates a new index.
+    # +table_schema+:: Schema of the table if the SQL create query creates a new table. The Schema is a Dictionary with columns' name as key and a ColumnInfo object as value.
+
+    def initialize(has_succeeded, sql_message, sql_state, database_name, index_name, table_schema)
+        super has_succeeded, sql_message, sql_state
+
+        @database_name = database_name
+        @index_name = index_name
+        @table_schema = table_schema
+    end
+
+    def database_name
+        @database_name
+    end
+
+    def index_name
+        @index_name
+    end
+
+    def table_schema
+        @table_schema
+    end
+end
+
+# Represents the concept of response in the case of an ALTER query executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaAlterResponse < PeaResponse
+
+    ##
+    # Initialize a new instance of the PeaAlterResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the query has correctly been executed. Set to true if the SQL state is 00000.
+    # +sql_message+:: SQL message return from the execution of the query.
+    # +sql_state+:: SQL state return from the execution of the query.
+    # +table_schema+:: Schema of the table if the SQL create query creates a new table. The Schema is a Dictionary with columns' name as key and a ColumnInfo object as value.
+
+    def initialize(has_succeeded, sql_message, sql_state, table_schema)
+        super has_succeeded, sql_message, sql_state
+        
+        @table_schema = table_schema
+    end
+
+    def table_schema
+        @table_schema
+    end
+end
+
+# Represents the concept of response in the case of a DROP query executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaDropResponse < PeaResponse
+
+    ##
+    # Initialize a new instance of the PeaDropResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the query has correctly been executed. Set to true if the SQL state is 00000.
+    # +sql_message+:: SQL message return from the execution of the query.
+    # +sql_state+:: SQL state return from the execution of the query.
+
+    def initialize(has_succeeded, sql_message, sql_state)
+        super has_succeeded, sql_message, sql_state
+    end
+end
+
+# Represents the concept of response in the case of a SELECT query executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaSelectResponse < PeaResponse
+
+    ##
+    # Initialize a new instance of the PeaSelectResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the query has correctly been executed. Set to true if the SQL state is 00000.
+    # +sql_message+:: SQL message return from the execution of the query.
+    # +sql_state+:: SQL state return from the execution of the query.
+    # +result+:: Results of the query in the form of an Dictionary where the columns' name are the key and the values are the elements of this column in the SQL table.
+    # +row_count+:: Represents the number of rows that have been retreived by the query.
+    # +columns_name+:: Array representing the name of the columns in the order of the SELECT query.
+    
+    def initialize(has_succeeded, sql_message, sql_state, result, row_count, columns_name)
+        super has_succeeded, sql_message, sql_state
+
+        @result = result
+        @row_count = row_count
+        @columns_name = columns_name
+    end
+
+    def result
+        @result
+    end
+
+    def row_count
+        @row_count
+    end
+
+    def columns_name
+        @columns_name
+    end
+end
+
+# Represents the concept of response in the case of an UPDATE query executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaUpdateResponse < PeaResponse
+
+    ##
+    # Initialize a new instance of the PeaResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the query has correctly been executed. Set to true if the SQL state is 00000.
+    # +sql_message+:: SQL message return from the execution of the query.
+    # +sql_state+:: SQL state return from the execution of the query.
+    # +row_count+:: Represents the number of rows that have been updated by the query.
+
+    def initialize(has_succeeded, sql_message, sql_state, row_count)
+        super has_succeeded, sql_message, sql_state
+        
+        @row_count = row_count
+    end
+
+    def row_count
+        @row_count
+    end
+end
+
+# Represents the concept of response in the case of a DELETE query executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaDeleteResponse < PeaResponse
+
+    ##
+    # Initialize a new instance of the PeaResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the query has correctly been executed. Set to true if the SQL state is 00000.
+    # +sql_message+:: SQL message return from the execution of the query.
+    # +sql_state+:: SQL state return from the execution of the query.
+    # +row_count+:: Represents the number of rows that have been updated by the query.
+
+    def initialize(has_succeeded, sql_message, sql_state, row_count)
+        super has_succeeded, sql_message, sql_state
+        
+        @row_count = row_count
+    end
+
+    def row_count
+        @row_count
+    end
+end
+
+# Represents the concept of response in the case of an INSERT query executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaInsertResponse < PeaResponse
+
+    ##
+    # Initialize a new instance of the PeaResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the query has correctly been executed. Set to true if the SQL state is 00000.
+    # +sql_message+:: SQL message return from the execution of the query.
+    # +sql_state+:: SQL state return from the execution of the query.
+    # +row_count+:: Represents the number of rows that have been updated by the query.
+
+    def initialize(has_succeeded, sql_message, sql_state, row_count)
+        super has_succeeded, sql_message, sql_state
+        
+        @row_count = row_count
+    end
+
+    def row_count
+        @row_count
+    end
+end
+
+# Represents the concept of response in the case of an OS/400 command executed on the database of an AS/400 server by a PeaClient object.
+
+class PeaCommandResponse
+
+    ##
+    # Initialize a new instance of the PeaCommandResponse class.
+    #
+    # Params:
+    # +has_succeeded+:: Boolean set to true if the command has correctly been executed meaning that no CPFxxxx was return. Still, description messages can be return along with CP*xxxx.
+    # +warnings+:: List of warnings that results form the command execution. Errors are of the form : CP*xxxx Description of the warning. 
+
+    def initialize(warnings)
+        @warnings = warnings
+    end
+
+    def warnings
+        @warnings
+    end
+end
+
+# Represents the concept of metadata for a column of an SQL table on the AS/400 server.
+class ColumnInfo
+
+    ##
+    # Initialize a new instance of the ColumnInfo class.
+    #
+    # Params:
+    # +column_name+:: Name of the column.
+    # +ordinal_position+:: Ordinal position of the column.
+    # +data_type+:: DB2 Type of the data contain in the column.
+    # +length+:: Length of the data contain in the column.
+    # +numeric_scale+:: Scale of the data contain in the column if numeric type.
+    # +is_nullable+:: Y/N depending on the nullability of the field.
+    # +is_updatable+:: Y/N depending on the updaptability of the field.
+    # +numeric_precision+:: Precision of the data contain in the column if numeric type.
+
+    def initialize(column_name, ordinal_position, data_type, length, numeric_scale, is_nullable, is_updatable, numeric_precision)
+        @column_name = column_name
+        @ordinal_position = ordinal_position
+        @data_type = data_type
+        @length = length
+        @numeric_scale = numeric_scale
+        @numeric_precision = numeric_precision
+        @is_nullable = is_nullable
+        @is_updatable = is_updatable
+        @numeric_precision = numeric_precision
+    end
+    
+    def column_name
+        @column_name
+    end
+
+    def ordinal_position
+        @ordinal_position
+    end
+
+    def data_type
+        @data_type
+    end
+
+    def length
+        @length
+    end
+
+    def numeric_scale
+        @numeric_scale
+    end
+
+    def numeric_precision
+        @numeric_precision
+    end
+
+    def is_nullable
+        @is_nullable
+    end
+
+    def is_updatable
+        @is_updatable
+    end
+
+    def numeric_precision
+        @numeric_precision
+    end
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: peasys-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+platform: ruby
+authors:
+- DIPS
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-07-15 00:00:00.000000000 Z
+dependencies: []
+description: Ruby client for IBM Db2 and peasys service
+email: dips@dips400.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pea_client.rb
+- lib/pea_exception.rb
+- lib/pea_response.rb
+homepage: https://github.com/dips400.com/peasys-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.19
+signing_key:
+specification_version: 4
+summary: Ruby client for IBM Db2 and peasys service
+test_files: []