bas 0.4.0 → 1.0.1

data/lib/bas/bot/fetch_ptos_from_notion.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "date"
+
+require_relative "./base"
+require_relative "../read/default"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchPtosFromNotion class serves as a bot implementation to read PTO's from a
+  # notion database and write them on a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     process_options: {
+  #       database_id: "notion database id",
+  #       secret: "notion secret"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "host",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "pto",
+  #       tag: "FetchPtosFromNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchPtosFromNotion.new(options)
+  #   bot.execute
+  #
+  class FetchPtosFromNotion < Bot::Base
+    # Read function to execute the default Read component
+    #
+    def read
+      reader = Read::Default.new
+
+      reader.execute
+    end
+
+    # Process function to execute the Notion utility to fetch PTO's from the notion database
+    #
+    def process
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        ptos_list = normalize_response(response.parsed_response["results"])
+
+        { success: { ptos: ptos_list } }
+      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 params
+      {
+        endpoint: "databases/#{process_options[:database_id]}/query",
+        secret: process_options[:secret],
+        method: "post",
+        body:
+      }
+    end
+
+    def body
+      { filter: { "or": conditions } }
+    end
+
+    def conditions
+      [
+        today_condition,
+        { property: "StartDateTime", date: { this_week: {} } },
+        { property: "EndDateTime", date: { this_week: {} } },
+        { property: "StartDateTime", date: { next_week: {} } },
+        { property: "EndDateTime", date: { next_week: {} } }
+      ]
+    end
+
+    def today_condition
+      today = Time.now.utc.strftime("%F").to_s
+      {
+        "and": [
+          { property: "StartDateTime", date: { on_or_before: today } },
+          { property: "EndDateTime", date: { on_or_after: today } }
+        ]
+      }
+    end
+
+    def normalize_response(results)
+      return [] if results.nil?
+
+      results.map do |pto|
+        pto_fields = pto["properties"]
+
+        name = extract_description_field_value(pto_fields["Description"])
+        start_date = extract_date_field_value(pto_fields["StartDateTime"])
+        end_date = extract_date_field_value(pto_fields["EndDateTime"])
+
+        description(name, start_date, end_date)
+      end
+    end
+
+    def description(name, start_date, end_date)
+      start = start_description(start_date)
+      finish = end_description(end_date)
+
+      "#{name} will not be working between #{start} and #{finish}. And returns the #{returns(finish)}"
+    end
+
+    def start_description(date)
+      date[:from]
+    end
+
+    def end_description(date)
+      return date[:from] if date[:to].nil?
+
+      date[:to]
+    end
+
+    def returns(date)
+      date.include?("T") ? "#{date} in the afternoon" : next_work_day(date)
+    end
+
+    def next_work_day(date)
+      datetime = DateTime.parse(date)
+
+      return_day = case datetime.wday
+                   when 5 then datetime + 3
+                   when 6 then datetime + 2
+                   else datetime + 1
+                   end
+
+      return_day.strftime("%A %B %d of %Y").to_s
+    end
+
+    def extract_description_field_value(data)
+      names = data["title"].map { |name| name["plain_text"] }
+
+      names.join(" ")
+    end
+
+    def extract_date_field_value(date)
+      {
+        from: extract_start_date(date),
+        to: extract_end_date(date)
+      }
+    end
+
+    def extract_start_date(data)
+      data["date"]["start"]
+    end
+
+    def extract_end_date(data)
+      data["date"]["end"]
+    end
+  end
+end

data/lib/bas/bot/format_birthdays.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FormatBirthdays class serves as a bot implementation to read birthdays from a
+  # PostgresDB database, format them with a specific template, and write them on a PostgresDB
+  # table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "FetchBirthdaysFromNotion"
+  #     },
+  #     process_options: {
+  #       template: "birthday template message"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "FormatBirthdays"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FormatBirthdays.new(options)
+  #   bot.execute
+  #
+  class FormatBirthdays < Bot::Base
+    BIRTHDAY_ATTRIBUTES = %w[name birthday_date].freeze
+
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # Process function to format the notification using a template
+    #
+    def process
+      return { success: { notification: "" } } if unprocessable_response
+
+      birthdays_list = read_response.data["birthdays"]
+
+      notification = birthdays_list.reduce("") do |payload, birthday|
+        "#{payload} #{build_template(BIRTHDAY_ATTRIBUTES, birthday)} \n"
+      end
+
+      { success: { notification: } }
+    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 build_template(attributes, instance)
+      template = process_options[:template]
+
+      attributes.reduce(template) do |formated_template, attribute|
+        formated_template.gsub("<#{attribute}>", instance[attribute].to_s)
+      end
+    end
+  end
+end

data/lib/bas/bot/format_emails.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FormatEmails class serves as a bot implementation to read emails from a
+  # PostgresDB database, format them with a specific template, and write them on a PostgresDB
+  # table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "FetchEmailsFromImap"
+  #     },
+  #     process_options: {
+  #       template: "emails template message"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "FormatEmails"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FormatEmails.new(options)
+  #   bot.execute
+  #
+  class FormatEmails < Bot::Base
+    EMAIL_ATTRIBUTES = %w[subject sender date].freeze
+    DEFAULT_TIME_ZONE = "+00:00"
+
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # Process function to format the notification using a template
+    #
+    def process
+      return { success: { notification: "" } } if unprocessable_response
+
+      emails_list = read_response.data["emails"]
+
+      notification = process_emails(emails_list).reduce("") do |payload, email|
+        "#{payload} #{build_template(EMAIL_ATTRIBUTES, email)} \n"
+      end
+
+      { success: { notification: } }
+    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 process_emails(emails)
+      emails.each do |email|
+        date = DateTime.parse(email["date"]).to_time
+        email["date"] = at_timezone(date)
+      end
+      emails.filter! { |email| email["date"] > time_window } unless process_options[:frequency].nil?
+
+      format_timestamp(emails)
+    end
+
+    def format_timestamp(emails)
+      emails.each { |email| email["date"] = email["date"].strftime("%F %r") }
+    end
+
+    def time_window
+      date_time = Time.now - (60 * 60 * process_options[:frequency])
+
+      at_timezone(date_time)
+    end
+
+    def at_timezone(date)
+      timezone = process_options[:timezone] || DEFAULT_TIME_ZONE
+
+      Time.at(date, in: timezone)
+    end
+
+    def build_template(attributes, instance)
+      template = process_options[:template]
+
+      attributes.reduce(template) do |formated_template, attribute|
+        formated_template.gsub("<#{attribute}>", instance[attribute].to_s)
+      end
+    end
+  end
+end

data/lib/bas/bot/format_wip_limit_exceeded.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FormatWipLimitExceeded class serves as a bot implementation to read exceeded domain wip
+  # counts by limits from a PostgresDB database, format them with a specific template, and write them
+  # on a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "CompareWipLimitCount"
+  #     },
+  #     process_options: {
+  #       template: "exceeded wip limit template message"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "FormatWipLimitExceeded"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FormatWipLimitExceeded.new(options)
+  #   bot.execute
+  #
+  class FormatWipLimitExceeded < Bot::Base
+    WIP_LIMIT_ATTRIBUTES = %w[domain exceeded].freeze
+
+    # read function to execute the PostgresDB Read component
+    #
+    def read
+      reader = Read::Postgres.new(read_options.merge(conditions))
+
+      reader.execute
+    end
+
+    # Process function to format the notification using a template
+    #
+    def process
+      return { success: { notification: "" } } if unprocessable_response
+
+      exceedded_limits_list = read_response.data["exceeded_domain_count"]
+
+      notification = exceedded_limits_list.reduce("") do |payload, exceedded_limit|
+        "#{payload} #{build_template(WIP_LIMIT_ATTRIBUTES, exceedded_limit)} \n"
+      end
+
+      { success: { notification: } }
+    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 build_template(attributes, instance)
+      template = process_options[:template]
+
+      attributes.reduce(template) do |formated_template, attribute|
+        formated_template.gsub("<#{attribute}>", instance[attribute].to_s)
+      end
+    end
+  end
+end

data/lib/bas/bot/garbage_collector.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/default"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::GarbageCollector class serves as a bot implementation to archive bot records from a
+  # PostgresDB database table and write a response on a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     process_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "localhost",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases"
+  #     }
+  #   }
+  #
+  #   bot = Bot::GarbageCollector.new(options)
+  #   bot.execute
+  #
+  class GarbageCollector < Bot::Base
+    SUCCESS_STATUS = "PGRES_COMMAND_OK"
+
+    # Read function to execute the default Read component
+    #
+    def read
+      reader = Read::Default.new
+
+      reader.execute
+    end
+
+    # Process function to update records in a PostgresDB database table
+    #
+    def process
+      response = Utils::Postgres::Request.execute(params)
+
+      if response.res_status == SUCCESS_STATUS
+        { success: { archived: true } }
+      else
+        { error: { message: response.result_error_message, status_code: response.res_status } }
+      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 params
+      {
+        connection: process_options[:connection],
+        query:
+      }
+    end
+
+    def query
+      "UPDATE #{process_options[:db_table]} SET archived=true WHERE archived=false"
+    end
+  end
+end

data/lib/bas/bot/humanize_pto.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../write/postgres"
+require_relative "../utils/openai/run_assistant"
+
+module Bot
+  ##
+  # The Bot::HumanizePto class serves as a bot implementation to read PTO's from a
+  # PostgresDb table, format them using an OpenAI Assistant with the OpenAI API, and
+  # write the response as a notification on 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: "FetchPtosFromNotion"
+  #     },
+  #     process_options: {
+  #       secret: "openai secret key",
+  #       assistant_id: "assistant_id",
+  #       prompt: "optional additional prompt"
+  #     },
+  #     write_options: {
+  #       connection: {
+  #         host: "host",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "pto",
+  #       tag: "HumanizePto"
+  #     }
+  #   }
+  #
+  #   bot = Bot::HumanizePto.new(options)
+  #   bot.execute
+  #
+  class HumanizePto < Bot::Base
+    DEFAULT_PROMPT = "{data}"
+
+    # 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 OpenaAI utility to process the PTO's
+    #
+    def process
+      return { success: { notification: "" } } if unprocessable_response
+
+      response = Utils::OpenAI::RunAssitant.execute(params)
+
+      if response.code != 200 || (!response["status"].nil? && response["status"] != "completed")
+        return error_response(response)
+      end
+
+      sucess_response(response)
+    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
+      {
+        assistant_id: process_options[:assistant_id],
+        secret: process_options[:secret],
+        prompt: build_prompt
+      }
+    end
+
+    def build_prompt
+      prompt = process_options[:prompt] || DEFAULT_PROMPT
+      ptos_list = read_response.data["ptos"]
+
+      ptos_list_formatted_string = ptos_list.join("\n")
+
+      prompt.gsub("{data}", ptos_list_formatted_string)
+    end
+
+    def sucess_response(response)
+      { success: { notification: response.parsed_response["data"].first["content"].first["text"]["value"] } }
+    end
+
+    def error_response(response)
+      { error: { message: response.parsed_response, status_code: response.code } }
+    end
+  end
+end