bas 1.5.2 → 1.6.0

data/lib/bas/bot/fetch_next_week_birthdays_from_notion.rb

@@ -1,142 +0,0 @@
-# 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

@@ -1,197 +0,0 @@
-# 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::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 # rubocop:disable Metrics/ClassLength
-    # 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"])
-        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?("T12") ? "#{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/fetch_ptos_from_notion.rb

@@ -1,160 +0,0 @@
-# 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: { filter: today_condition }
-      }
-    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?("T12") ? "#{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

@@ -1,97 +0,0 @@
-# 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_do_bill_alert.rb

@@ -1,108 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./base"
-require_relative "../read/postgres"
-require_relative "../write/postgres"
-
-module Bot
-  ##
-  # The Bot::FormatDoBillAlert class serves as a bot implementation to format DigitalOcean bill
-  # alerts 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: "do_billing",
-  #       tag: "FetchBillingFromDigitalOcean"
-  #     },
-  #     process_options: {
-  #       threshold: 7
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "do_billing",
-  #       tag: "FormatDoBillAlert"
-  #     }
-  #   }
-  #
-  #   bot = Bot::FormatDoBillAlert.new(options)
-  #   bot.execute
-  #
-  class FormatDoBillAlert < 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 format the notification using a template
-    #
-    def process
-      return { success: { notification: "" } } if unprocessable_response || !threshold_exceeded
-
-      { success: { notification: message } }
-    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 threshold_exceeded
-      return false if billing.zero?
-
-      usage > process_options[:threshold]
-    end
-
-    def usage
-      billing - last_billing
-    end
-
-    def billing
-      read_response.data["billing"]["month_to_date_balance"].to_f
-    end
-
-    def last_billing
-      read_response.data["last_billing"]["month_to_date_balance"].to_f
-    end
-
-    def message
-      balance = billing
-      threshold = process_options[:threshold]
-
-      ":warning: The **DigitalOcean** daily usage was exceeded. \
-      Current balance: #{balance}, Threshold: #{threshold}, \
-      Current daily usage: #{usage.round(3)}"
-    end
-  end
-end