bas 0.4.0 → 1.0.0

data/lib/bas/bot/fetch_domains_wip_counts_from_notion.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/default"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchDomainsWipCountsFromNotion class serves as a bot implementation to fetch work items
+  # in progress or in hold from a Notion database, count how many are by domain, 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: "use_cases",
+  #       tag: "FetchDomainsWipCountsFromNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchDomainsWipCountsFromNotion.new(options)
+  #   bot.execute
+  #
+  class FetchDomainsWipCountsFromNotion < 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 work item from the notion database
+    #
+    def process
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        work_items_domains = normalize_response(response.parsed_response["results"])
+        domain_wip_count = count_domain_items(work_items_domains)
+
+        { success: { domain_wip_count: } }
+      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: {
+          "and": [
+            { property: "OK", formula: { string: { contains: "✅" } } },
+            { "or": status_conditions }
+          ]
+        }
+      }
+    end
+
+    def status_conditions
+      [
+        { property: "Status", status: { equals: "In Progress" } },
+        { property: "Status", status: { equals: "On Hold" } }
+      ]
+    end
+
+    def normalize_response(results)
+      return [] if results.nil?
+
+      results.map do |pto|
+        work_item_fields = pto["properties"]
+
+        {
+          "domain" => extract_domain_field_value(work_item_fields["Responsible domain"])
+        }
+      end
+    end
+
+    def extract_domain_field_value(data)
+      data["select"]["name"]
+    end
+
+    def count_domain_items(work_items_list)
+      domain_work_items = work_items_list.group_by { |work_item| work_item["domain"] }
+
+      domain_work_items.transform_values(&:count)
+    end
+  end
+end

data/lib/bas/bot/fetch_domains_wip_limit_from_notion.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchDomainsWipLimitFromNotion class serves as a bot implementation to fetch domains wip
+  # limits from a Notion database, merge them with the count of how many are by domain, and write them
+  # on a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   options = {
+  #     read_options: {
+  #       connection: {
+  #         host: "host",
+  #         port: 5432,
+  #         dbname: "bas",
+  #         user: "postgres",
+  #         password: "postgres"
+  #       },
+  #       db_table: "use_cases",
+  #       tag: "FetchDomainsWipCountsFromNotion"
+  #     },
+  #     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: "use_cases",
+  #       tag: "FetchDomainsWipLimitFromNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchDomainsWipLimitFromNotion.new(options)
+  #   bot.execute
+  #
+  class FetchDomainsWipLimitFromNotion < 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 Notion utility to fetch domain wip limits from the notion database
+    #
+    def process
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        domains_limits = normalize_response(response.parsed_response["results"])
+
+        wip_limit_data = wip_count.merge({ domains_limits: })
+
+        { success: wip_limit_data }
+      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
+      {
+        endpoint: "databases/#{process_options[:database_id]}/query",
+        secret: process_options[:secret],
+        method: "post",
+        body:
+      }
+    end
+
+    def body
+      {
+        filter: {
+          property: "WIP + On Hold limit",
+          number: { is_not_empty: true }
+        }
+      }
+    end
+
+    def normalize_response(results)
+      return [] if results.nil?
+
+      results.reduce({}) do |domains_limits, domain_wip_limit|
+        domain_fields = domain_wip_limit["properties"]
+
+        domain = extract_domain_name_value(domain_fields["Name"])
+        limit = extract_domain_limit_value(domain_fields["WIP + On Hold limit"])
+
+        domains_limits.merge({ domain => limit })
+      end
+    end
+
+    def extract_domain_name_value(data)
+      data["title"].first["plain_text"]
+    end
+
+    def extract_domain_limit_value(data)
+      data["number"]
+    end
+
+    def wip_count
+      read_response.data.nil? ? {} : read_response.data
+    end
+  end
+end

data/lib/bas/bot/fetch_emails_from_imap.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/default"
+require_relative "../utils/imap/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchEmailsFromImap class serves as a bot implementation to fetch emails from a imap server
+  # and write them on a PostgresDB table with a specific format.
+  #
+  # <br>
+  # <b>Example</b>
+  #
+  #   params = {
+  #     process_options: {
+  #       refresh_token: "email server refresh token",
+  #       client_id: "email server client it",
+  #       client_secret: "email server client secret",
+  #       token_uri: "email server refresh token uri",
+  #       email_domain: "email server domain",
+  #       email_port: "email server port",
+  #       user_email: "email to be access",
+  #       search_email: "email to be search",
+  #       inbox: "inbox to be search"
+  #     },
+  #     write_options: {
+  #       connection:,
+  #       db_table: "use_cases",
+  #       tag: "FetchEmailsFromImap"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchEmailsFromImap.new(options)
+  #   bot.execute
+  #
+  class FetchEmailsFromImap < Bot::Base
+    # Read function to execute the default Read component
+    #
+    def read
+      reader = Read::Default.new
+
+      reader.execute
+    end
+
+    # Process function to request email from an imap server using the imap utility
+    #
+    def process
+      response = Utils::Imap::Request.new(process_options, query).execute
+
+      if response[:error]
+        { error: response }
+      else
+        emails = normalize_response(response[:emails])
+
+        { success: { emails: } }
+      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 query
+      yesterday = (Time.now - (60 * 60 * 24)).strftime("%d-%b-%Y")
+
+      ["TO", process_options[:search_email], "SINCE", yesterday]
+    end
+
+    def normalize_response(results)
+      return [] if results.nil?
+
+      results.map do |value|
+        message = value[:message]
+
+        {
+          "message_id": value[:message_id],
+          "sender" => extract_sender(message),
+          "date" => message.date,
+          "subject" => message.subject
+        }
+      end
+    end
+
+    def extract_sender(value)
+      mailbox = value.sender[0]["mailbox"]
+      host = value.sender[0]["host"]
+
+      "#{mailbox}@#{host}"
+    end
+  end
+end

data/lib/bas/bot/fetch_next_week_birthdays_from_notion.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/postgres"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchNextWeekBirthdaysFromNotion class serves as a bot implementation to read next
+  # week birthdays 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: "birthdays",
+  #       tag: "FetchNextWeekBirthdaysFromNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchNextWeekBirthdaysFromNotion.new(options)
+  #   bot.execute
+  #
+  class FetchNextWeekBirthdaysFromNotion < Bot::Base
+    DAYS_BEFORE = 7
+
+    # 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 Notion utility to fetch PTO's from the notion database
+    #
+    def process
+      response = Utils::Notion::Request.execute(params)
+
+      if response.code == 200
+        birthdays_list = normalize_response(response.parsed_response["results"])
+
+        { success: { birthdays: birthdays_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 conditions
+      {
+        where: "archived=$1 AND tag=$2 AND stage=$3 ORDER BY inserted_at ASC",
+        params: [false, read_options[:tag], "unprocessed"]
+      }
+    end
+
+    def params
+      {
+        endpoint: "databases/#{process_options[:database_id]}/query",
+        secret: process_options[:secret],
+        method: "post",
+        body:
+      }
+    end
+
+    def body
+      {
+        filter: {
+          and: [{ property: "BD_this_year", date: { equals: n_days_from_now } }] + last_edited_condition
+        }
+      }
+    end
+
+    def last_edited_condition
+      return [] if read_response.inserted_at.nil?
+
+      [
+        {
+          timestamp: "last_edited_time",
+          last_edited_time: { on_or_after: read_response.inserted_at }
+        }
+      ]
+    end
+
+    def n_days_from_now
+      date = Time.now.utc + days_in_second(days_before)
+
+      date.utc.strftime("%F").to_s
+    end
+
+    def days_before
+      process_options[:days_before] || DAYS_BEFORE
+    end
+
+    def days_in_second(days)
+      days * 24 * 60 * 60
+    end
+
+    def normalize_response(results)
+      return [] if results.nil?
+
+      results.map do |value|
+        birthday_fields = value["properties"]
+
+        {
+          "name" => extract_rich_text_field_value(birthday_fields["Complete Name"]),
+          "birthday_date" => extract_date_field_value(birthday_fields["BD_this_year"])
+        }
+      end
+    end
+
+    def extract_rich_text_field_value(data)
+      data["rich_text"][0]["plain_text"]
+    end
+
+    def extract_date_field_value(data)
+      data["formula"]["date"]["start"]
+    end
+  end
+end

data/lib/bas/bot/fetch_next_week_ptos_from_notion.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative "./base"
+require_relative "../read/default"
+require_relative "../utils/notion/request"
+require_relative "../write/postgres"
+
+module Bot
+  ##
+  # The Bot::FetchNextWeekPtosFromNotion class serves as a bot implementation to read next week
+  # 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: "FetchNextWeekPtosFromNotion"
+  #     }
+  #   }
+  #
+  #   bot = Bot::FetchNextWeekPtosFromNotion.new(options)
+  #   bot.execute
+  #
+  class FetchNextWeekPtosFromNotion < 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 next week 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
+      monday, sunday = next_week_dates
+
+      {
+        filter: {
+          or: [
+            belong_next_week("StartDateTime", monday, sunday),
+            belong_next_week("EndDateTime", monday, sunday),
+            cover_next_week(monday, sunday)
+          ]
+        }
+      }
+    end
+
+    def next_week_dates
+      monday = next_week_monday
+      sunday = monday + 6
+
+      [monday, sunday]
+    end
+
+    def next_week_monday
+      today = Date.today
+      week_day = today.wday
+
+      days = week_day.zero? ? 1 : 8 - week_day
+
+      today + days
+    end
+
+    def belong_next_week(property, after_day, before_day)
+      {
+        and: [
+          { property:, date: { on_or_after: after_day } },
+          { property:, date: { on_or_before: before_day } }
+        ]
+      }
+    end
+
+    def cover_next_week(monday, sunday)
+      {
+        and: [
+          { property: "EndDateTime", date: { on_or_after: sunday } },
+          { property: "StartDateTime", date: { on_or_before: monday } }
+        ]
+      }
+    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"]),
+          "StartDateTime" => extract_date_field_value(pto_fields["StartDateTime"]),
+          "EndDateTime" => extract_date_field_value(pto_fields["EndDateTime"])
+        }
+      end
+    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