bas 0.4.0 → 1.0.0

data/lib/bas/bot/notify_discord.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+require_relative "../utils/discord/integration"
+
+module Bot
+  ##
+  # The Bot::NotifyDiscord class serves as a bot implementation to send messages to a
+  # Discord readed from a PostgresDB table.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "host",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "pto",
+  #       tag: "HumanizePto"
+  #     },
+  #     process_options: {
+  #       name: "bot name to be shown on discord",
+  #       webhook: "discord webhook"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "host",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "pto",
+  #       tag: "NotifyDiscord"
+  #     }
+  #   }
+  #
+  #   bot = Bot::NotifyDiscord.new(options)
+  #   bot.execute
+  #
+  class NotifyDiscord < Bot::Base
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # process function to execute the Discord utility to send the PTO's notification
+    #
+    def process
+      return { success: {} } if unprocessable_response
+
+      response = Utils::Discord::Integration.execute(params)
+
+      if response.code == 204
+        { success: {} }
+      else
+        { error: { message: response.parsed_response, status_code: response.code } }
+      end
+    end
+
+    # write function to execute the PostgresDB write component
+    #
+    def write
+      write = Write::Postgres.new(write_options, process_response)
+
+      write.execute
+    end
+
+    private
+
+    def conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def params
+      {
+        name: process_options[:name],
+        notification: read_response.data["notification"],
+        webhook: process_options[:webhook]
+      }
+    end
+  end
+end

data/lib/bas/read/base.rb

@@ -1,43 +1,30 @@
 # frozen_string_literal: true
 
-require_relative "../domain/exceptions/function_not_implemented"
+require_relative "../utils/exceptions/function_not_implemented"
 
 module Read
   ##
-  # The Read::Base class serves as the foundation for implementing specific data readers within the Read module.
-  # Operating as an interface, this class defines essential attributes and methods, providing a blueprint for creating
-  # custom readers tailored to different data sources.
+  # The Read::Base class serves as the foundation for implementing specific data read components within
+  # the Read module. Operating as an interface, this class defines essential attributes and methods,
+  # providing a blueprint for creating custom read components tailored to different data sources.
   #
   class Base
     attr_reader :config
 
-    # Initializes the reader with essential configuration parameters.
+    # Initializes the read with essential configuration parameters.
     #
-    def initialize(config)
+    def initialize(config = {})
       @config = config
     end
 
-    # A method meant to execute the read request from an specific source depending on the implementation.
-    # Must be overridden by subclasses, with specific logic based on the use case.
+    # A method meant to execute the read request from an specific <b>common storage</b>.
+    # Must be overridden by subclasses, with specific logic based on the storage source.
     #
     # <br>
-    # <b>raises</b> <tt>Domain::Exceptions::FunctionNotImplemented</tt> when missing implementation.
+    # <b>raises</b> <tt>Utils::Exceptions::FunctionNotImplemented</tt> when missing implementation.
     #
     def execute
-      raise Domain::Exceptions::FunctionNotImplemented
-    end
-
-    protected
-
-    # A method meant to read from the source, retrieven the required data
-    # from an specific filter configuration depending on the use case implementation.
-    # Must be overridden by subclasses, with specific logic based on the use case.
-    #
-    # <br>
-    # <b>raises</b> <tt>Domain::Exceptions::FunctionNotImplemented</tt> when missing implementation.
-    #
-    def read(*_filters)
-      raise Domain::Exceptions::FunctionNotImplemented
+      raise Utils::Exceptions::FunctionNotImplemented
     end
   end
 end

data/lib/bas/read/default.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "./types/response"
+
+module Read
+  ##
+  # This class is an implementation of the Read::Base interface, specifically designed
+  # for bots who don't read from a <b>common storage</b>".
+  #
+  class Default < Read::Base
+    def execute
+      Read::Types::Response.new
+    end
+  end
+end

data/lib/bas/read/postgres.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+
+require_relative "./base"
+require_relative "../utils/postgres/request"
+require_relative "./types/response"
+
+module Read
+  ##
+  # This class is an implementation of the Read::Base interface, specifically designed
+  # to read from a PostgresDB used as <b>common storage</b>.
+  #
+  class Postgres < Read::Base
+    # Execute the Postgres utility to read data from the <b>common storage</b>
+    #
+    def execute
+      response = Utils::Postgres::Request.execute(params)
+
+      unless response.values == []
+        id = response.values.first[0]
+        data = JSON.parse(response.values.first[1])
+        inserted_at = response.values.first[2]
+      end
+
+      Read::Types::Response.new(id, data, inserted_at)
+    end
+
+    private
+
+    def params
+      {
+        connection: config[:connection],
+        query: build_query
+      }
+    end
+
+    def build_query
+      query = "SELECT id, data, inserted_at FROM #{config[:db_table]} WHERE status='success' AND #{config[:where]}"
+
+      [query, config[:params]]
+    end
+  end
+end

data/lib/bas/read/types/response.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Read
+  module Types
+    ##
+    # Represents a response from a read component. It encapsulates the requested data
+    # from the <b>common storage</b> to be processed by a Bot.
+    class Response
+      attr_reader :id, :data, :inserted_at
+
+      def initialize(id = nil, response = {}, inserted_at = nil)
+        @id = id
+        @data = response
+        @inserted_at = inserted_at
+      end
+    end
+  end
+end

data/lib/bas/utils/discord/integration.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+module Utils
+  module Discord
+    ##
+    # This module is a Discord utility for sending messages to Discord.
+    #
+    module Integration
+      # Implements the sending process logic to Discord. It sends a POST request to
+      # the Discord webhook with the specified payload.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>webhook</tt> Discord webhook integration.
+      # * <tt>name</tt> Name of the discord user to send the message.
+      # * <tt>notification</tt> Text of the notification to be sent.
+      #
+      # <br>
+      # <b>returns</b> <tt>HTTParty::Response</tt>
+      #
+      def self.execute(params)
+        HTTParty.post(params[:webhook], { body: body(params), headers: })
+      end
+
+      # Request body
+      #
+      def self.body(params)
+        {
+          username: params[:name],
+          content: params[:notification]
+        }.to_json
+      end
+
+      # Request headers
+      #
+      def self.headers
+        { "Content-Type" => "application/json" }
+      end
+    end
+  end
+end

data/lib/bas/utils/exceptions/function_not_implemented.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Utils
+  module Exceptions
+    ##
+    # Representation for errors that occur when a function has not been implemented yet.
+    # It inherits from StandardError, and allows developers to raise a specific exception
+    # when a required function remains unimplemented in a subclass.
+    #
+    class FunctionNotImplemented < StandardError
+      def initialize(message = "The function haven't been implemented yet.")
+        super(message)
+      end
+    end
+  end
+end

data/lib/bas/utils/exceptions/invalid_process_response.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Utils
+  module Exceptions
+    ##
+    # Representation for errors that occur when a process function of a Bot returns
+    # something different than a Hash type object.
+    # It inherits from StandardError.
+    #
+    class InvalidProcessResponse < StandardError
+      def initialize(message = "The Process response should be a Hash type object")
+        super(message)
+      end
+    end
+  end
+end

data/lib/bas/utils/imap/request.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "net/imap"
+require "gmail_xoauth"
+require "httparty"
+
+module Utils
+  module Imap
+    ##
+    # This module is a Imap utility for request emails from an Imap server
+    #
+    class Request
+      def initialize(params, query)
+        @refresh_token = params[:refresh_token]
+        @client_id = params[:client_id]
+        @client_secret = params[:client_secret]
+        @token_uri = params[:token_uri]
+        @email_domain = params[:email_domain]
+        @email_port = params[:email_port]
+        @user_email = params[:user_email]
+        @inbox = params[:inbox]
+        @query = query
+
+        @emails = []
+      end
+
+      # Execute the imap requets after authenticate the email with the credentials
+      #
+      def execute
+        response = refresh_token
+
+        return { error: response } unless response["error"].nil?
+
+        imap_fetch(response["access_token"])
+
+        { emails: @emails }
+      rescue StandardError => e
+        { error: e.to_s }
+      end
+
+      private
+
+      def imap_fetch(access_token)
+        imap = Net::IMAP.new(@email_domain, port: @email_port, ssl: true)
+
+        imap.authenticate("XOAUTH2", @user_email, access_token)
+
+        imap.examine(@inbox)
+
+        @emails = fetch_emails(imap)
+
+        imap.logout
+        imap.disconnect
+      end
+
+      def fetch_emails(imap)
+        imap.search(@query).map do |message_id|
+          { message_id:, message: imap.fetch(message_id, "ENVELOPE")[0].attr["ENVELOPE"] }
+        end
+      end
+
+      def refresh_token
+        HTTParty.post(@token_uri, { body: })
+      end
+
+      def body
+        {
+          "grant_type" => "refresh_token",
+          "refresh_token" => @refresh_token,
+          "client_id" => @client_id,
+          "client_secret" => @client_secret
+        }
+      end
+    end
+  end
+end

data/lib/bas/utils/notion/request.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+module Utils
+  module Notion
+    ##
+    # This module is a Notion utility for sending request to create, update, or delete
+    # Notion resources.
+    #
+    module Request
+      NOTION_BASE_URL = "https://api.notion.com/v1"
+
+      # Implements the request process logic to Notion.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>method</tt> HTTP request method: post, get, put, etc.
+      # * <tt>body</tt> Request body (Hash).
+      # * <tt>endpoint</tt> Notion resource endpoint.
+      # * <tt>secret</tt> Notion secret.
+      #
+      # <br>
+      # <b>returns</b> <tt>HTTParty::Response</tt>
+      #
+      def self.execute(params)
+        url = "#{NOTION_BASE_URL}/#{params[:endpoint]}"
+
+        headers = notion_headers(params[:secret])
+
+        HTTParty.send(params[:method], url, { body: params[:body].to_json, headers: })
+      end
+
+      # Request headers
+      #
+      def self.notion_headers(secret)
+        {
+          "Authorization" => "Bearer #{secret}",
+          "Content-Type" => "application/json",
+          "Notion-Version" => "2022-06-28"
+        }
+      end
+    end
+  end
+end

data/lib/bas/utils/openai/run_assistant.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+module Utils
+  module OpenAI
+    ##
+    # This module is an OpenAI utility for using an already created OpenAI Assistant
+    # and get an AI response depending on the Assistant's instructions and prompt.
+    #
+    module RunAssitant
+      OPENAI_BASE_URL = "https://api.openai.com"
+      DEFAULT_N_CHOICES = 1
+
+      # Implements the request process logic to the OpenAI Assitant.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>assistant_id</tt> Assistant id
+      # * <tt>prompt</tt> Text that communicates to AI to provide it more context.
+      # * <tt>secret</tt> OpenAI Secret API Key.
+      #
+      # <br>
+      # <b>returns</b> <tt>HTTParty::Response</tt>
+      #
+      def self.execute(params)
+        @params = params
+
+        run = create_thread_and_run
+
+        return run unless run.code == 200
+
+        run_fetched = poll_run(run.parsed_response)
+
+        return run_fetched unless run_fetched["status"] == "completed"
+
+        list_messages(run_fetched)
+      end
+
+      # Creates an OpenAI Thread and a Run using the given assistant_id and prompt.
+      #
+      def self.create_thread_and_run
+        url = "#{OPENAI_BASE_URL}/v1/threads/runs"
+
+        HTTParty.post(url, { body:, headers: })
+      end
+
+      # Retrieve the list of messages of a thread.
+      #
+      def self.list_messages(run)
+        url = "#{OPENAI_BASE_URL}/v1/threads/#{run["thread_id"]}/messages"
+
+        HTTParty.get(url, { headers: })
+      end
+
+      # Request body
+      #
+      def self.body
+        {
+          assistant_id: @params[:assistant_id],
+          thread: {
+            messages: [
+              role: "user",
+              content: @params[:prompt]
+            ]
+          }
+        }.to_json
+      end
+
+      # Request headers
+      #
+      def self.headers
+        {
+          "Authorization" => "Bearer #{@params[:secret]}",
+          "Content-Type" => "application/json",
+          "OpenAI-Beta" => "assistants=v2"
+        }
+      end
+
+      # Polls the Run until it is processed.
+      #
+      def self.poll_run(run)
+        url = "#{OPENAI_BASE_URL}/v1/threads/#{run["thread_id"]}/runs/#{run["id"]}"
+
+        while true
+          run_fetched = HTTParty.get(url, { headers: })
+          status = run_fetched["status"]
+
+          case status
+          when "queued", "in_progress", "cancelling" then sleep 1 # Wait one second and poll again
+          when "completed", "requires_action", "cancelled", "failed", "expired" then break
+          end
+        end
+
+        run_fetched
+      end
+    end
+  end
+end

data/lib/bas/utils/postgres/request.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "pg"
+
+module Utils
+  module Postgres
+    ##
+    # This module is a PostgresDB utility to make requests to a Postgres database.
+    #
+    module Request
+      # Implements the request process logic to the PostgresDB table.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>connection</tt> Connection parameters to the database: `host`, `port`, `dbname`, `user`, `password`.
+      # * <b>query</b>:
+      #   * <tt>String</tt>: String with the SQL query to be executed.
+      #   * <tt>Array</tt>: Two element array, where the first element is the SQL query (string), and the
+      #                     second one an array of elements to be interpolared in the query when using "$1, $2, ...".
+      #
+      # <br>
+      # <b>returns</b> <tt>HTTParty::Response</tt>
+      #
+      def self.execute(params)
+        pg_connection = PG::Connection.new(params[:connection])
+
+        execute_query(pg_connection, params[:query])
+      end
+
+      # Execute the Postgres query
+      #
+      # <br>
+      # <b>pg_connection</b>: PG::Connection object configured with the database connection.
+      # <b>query</b>:
+      # * <tt>String</tt>: String with the SQL query to be executed.
+      # * <tt>Array</tt>: Two element array, where the first element is the SQL query (string), and the
+      #                   second one an array of elements to be interpolared in the query when using "$1, $2, ...".
+      #
+      def self.execute_query(pg_connection, query)
+        if query.is_a? String
+          pg_connection.exec(query)
+        else
+          sentence, params = query
+
+          pg_connection.exec_params(sentence, params)
+        end
+      end
+    end
+  end
+end

data/lib/bas/version.rb

@@ -2,5 +2,5 @@
 
 module Bas
   # Gem version
-  VERSION = "0.4.0"
+  VERSION = "1.0.0"
 end

data/lib/bas/write/base.rb

@@ -1,36 +1,31 @@
 # frozen_string_literal: true
 
-require_relative "../domain/exceptions/function_not_implemented"
+require_relative "../utils/exceptions/function_not_implemented"
 
 module Write
   ##
-  # The Write::Base class serves as the foundation for implementing specific data write within the Write module.
-  # Operating as an interface, this class defines essential attributes and methods, providing a blueprint for creating
-  # a custom write.
+  # The Write::Base class serves as the foundation for implementing specific data write components within
+  # the Write module. Operating as an interface, this class defines essential attributes and methods,
+  # providing a blueprint for creating custom write components tailored to different data storages.
   #
   class Base
-    attr_reader :config
+    attr_reader :config, :process_response
 
     # Initializes the write with essential configuration parameters.
     #
-    def initialize(config = {})
+    def initialize(config, process_response = nil)
       @config = config
+      @process_response = process_response
     end
 
-    # A method meant to execute the write request to an specific destination depending on the implementation.
-    # Must be overridden by subclasses, with specific logic based on the use case.
+    # A method meant to execute the write request to an specific <b>common storage</b>.
+    # Must be overridden by subclasses, with specific logic based on the storage destination.
     #
     # <br>
-    # <b>raises</b> <tt>Domain::Exceptions::FunctionNotImplemented</tt> when missing implementation.
+    # <b>raises</b> <tt>Utils::Exceptions::FunctionNotImplemented</tt> when missing implementation.
     #
-    def execute(_process_response)
-      raise Domain::Exceptions::FunctionNotImplemented
-    end
-
-    protected
-
-    def write(_method, _data)
-      raise Domain::Exceptions::FunctionNotImplemented
+    def execute
+      raise Utils::Exceptions::FunctionNotImplemented
     end
   end
 end

data/lib/bas/write/postgres.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../version"
+require_relative "../utils/postgres/request"
+
+module Write
+  ##
+  # This class is an implementation of the Write::Base interface, specifically designed
+  # to wtite to a PostgresDB used as <b>common storage</b>.
+  #
+  class Postgres < Write::Base
+    PTO_PARAMS = "data, tag, archived, stage, status, error_message, version"
+
+    # Execute the Postgres utility to write data in the <b>common storage</b>
+    #
+    def execute
+      Utils::Postgres::Request.execute(params)
+    end
+
+    private
+
+    def params
+      {
+        connection: config[:connection],
+        query: build_query
+      }
+    end
+
+    def build_query
+      query = "INSERT INTO #{config[:db_table]} (#{PTO_PARAMS}) VALUES ($1, $2, $3, $4, $5, $6, $7);"
+      params = build_params
+
+      [query, params]
+    end
+
+    def build_params
+      if process_response[:success]
+        [process_response[:success].to_json, config[:tag], false, "unprocessed", "success", nil, Bas::VERSION]
+      else
+        [nil, config[:tag], false, "unprocessed", "failed", process_response[:error].to_json, Bas::VERSION]
+      end
+    end
+  end
+end