bas 1.5.2 → 1.6.0

data/lib/bas/bot/compare_wip_limit_count.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./base"
-require_relative "../read/postgres"
-require_relative "../write/postgres"
-
-module Bot
-  ##
-  # The Bot::CompareWipLimitCount class serves as a bot implementation to read domains wip limits and
-  # counts from a PostgresDB database, compare the values to find exceeded counts, 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: "FetchDomainsWipLimitFromNotion"
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "use_cases",
-  #       tag: "CompareWipLimitCount"
-  #     }
-  #   }
-  #
-  #   bot = Bot::CompareWipLimitCount.new(options)
-  #   bot.execute
-  #
-  class CompareWipLimitCount < 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 compare the domains wip counts and limits
-    #
-    def process
-      return { success: { exceeded_domain_count: {} } } if unprocessable_response
-
-      domains_limits = read_response.data["domains_limits"]
-      domain_wip_count = read_response.data["domain_wip_count"]
-
-      exceeded_domain_count = exceedded_counts(domains_limits, domain_wip_count)
-
-      { success: { exceeded_domain_count: } }
-    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 exceedded_counts(limits, counts)
-      counts.to_a.map do |domain_wip_count|
-        domain, count = domain_wip_count
-        domain_limit = limits[domain]
-
-        { domain:, exceeded: count - domain_limit } if count > domain_limit
-      end.compact
-    end
-  end
-end

data/lib/bas/bot/create_work_item.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-require_relative "./base"
-require_relative "../read/postgres"
-require_relative "../utils/notion/request"
-require_relative "../utils/notion/types"
-require_relative "../write/postgres"
-
-module Bot
-  ##
-  # The Bot::CreateWorkItem class serves as a bot implementation to create "work items" on a
-  # notion database using information of a GitHub issue.
-  #
-  # <br>
-  # <b>Example</b>
-  #
-  #   options = {
-  #     read_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "github_issues",
-  #       tag: "CreateWorkItemRequest"
-  #     },
-  #     process_options: {
-  #       database_id: "notion database id",
-  #       secret: "notion secret",
-  #       domain: "domain association",
-  #       status: "default status",
-  #       work_item_type: "work_item_type",
-  #       project: "project id"
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "github_issues",
-  #       tag: "CreateWorkItem"
-  #     }
-  #   }
-  #
-  #   bot = Bot::VerifyIssueExistanceInNotion.new(options)
-  #   bot.execute
-  #
-  class CreateWorkItem < Bot::Base
-    include Utils::Notion::Types
-
-    UPDATE_REQUEST = "UpdateWorkItemRequest"
-    STATUS = "Backlog"
-
-    # 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 create work items on a notion
-    # database
-    #
-    def process
-      return { success: { created: nil } } if unprocessable_response
-
-      response = Utils::Notion::Request.execute(params)
-
-      if response.code == 200
-        { success: { issue: read_response.data["issue"], notion_wi: response["id"] } }
-      else
-        { error: { message: response.parsed_response, status_code: response.code } }
-      end
-    end
-
-    # write function to execute the PostgresDB write component
-    #
-    def write
-      options = write_options.merge({ tag: })
-
-      write = Write::Postgres.new(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: "pages",
-        secret: process_options[:secret],
-        method: "post",
-        body:
-      }
-    end
-
-    def body
-      {
-        parent: { database_id: process_options[:database_id] },
-        properties:
-      }
-    end
-
-    def properties # rubocop:disable Metrics/AbcSize
-      {
-        "Responsible domain": select(read_response.data["domain"]),
-        "Github Issue Id": rich_text(read_response.data["issue"]["id"].to_s),
-        "Status": status(STATUS),
-        "Detail": title(read_response.data["issue"]["title"])
-      }.merge(work_item_type)
-    end
-
-    def work_item_type
-      case read_response.data["work_item_type"]
-      when "activity" then { "Activity": relation(read_response.data["type_id"]) }
-      when "project" then { "Project": relation(read_response.data["type_id"]) }
-      else {}
-      end
-    end
-
-    def tag
-      return write_options[:tag] if process_response[:success].nil? || process_response[:success][:notion_wi].nil?
-
-      UPDATE_REQUEST
-    end
-  end
-end

data/lib/bas/bot/fetch_billing_from_digital_ocean.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./base"
-require_relative "../read/postgres"
-require_relative "../utils/digital_ocean/request"
-require_relative "../write/postgres"
-
-module Bot
-  ##
-  # The Bot::FetchBillingFromDigitalOcean class serves as a bot implementation to read digital
-  # ocean current billing using the DigitalOcean API
-  #
-  # <br>
-  # <b>Example</b>
-  #
-  #   options = {
-  #     process_options: {
-  #       secret: "digital_ocean_secret_key"
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "host",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "use_cases",
-  #       tag: "FetchBillingFromDigitalOcean"
-  #     }
-  #   }
-  #
-  #   bot = Bot::FetchBillingFromDigitalOcean.new(options)
-  #   bot.execute
-  #
-  class FetchBillingFromDigitalOcean < Bot::Base
-    # Read function to execute the default Read component
-    #
-    def read
-      reader = Read::Postgres.new(read_options.merge(conditions))
-
-      reader.execute
-    end
-
-    # Process function to execute the DigitalOcean utility to fetch bills
-    #
-    def process
-      response = Utils::DigitalOcean::Request.execute(params)
-
-      if response.code == 200
-        { success: { billing: response.parsed_response, last_billing: } }
-      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 ORDER BY inserted_at DESC",
-        params: [false, read_options[:tag]]
-      }
-    end
-
-    def params
-      {
-        endpoint: "customers/my/balance",
-        secret: process_options[:secret],
-        method: "get",
-        body: {}
-      }
-    end
-
-    def last_billing
-      read_response.data.nil? ? nil : read_response.data["billing"]
-    end
-  end
-end

data/lib/bas/bot/fetch_birthdays_from_notion.rb

@@ -1,128 +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::FetchBirthdaysFromNotion class serves as a bot implementation to read 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: "use_cases",
-  #       tag: "FetchBirthdaysFromNotion"
-  #     }
-  #   }
-  #
-  #   bot = Bot::FetchBirthdaysFromNotion.new(options)
-  #   bot.execute
-  #
-  class FetchBirthdaysFromNotion < 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 birthdays from a 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 ORDER BY inserted_at DESC",
-        params: [false, read_options[:tag]]
-      }
-    end
-
-    def params
-      {
-        endpoint: "databases/#{process_options[:database_id]}/query",
-        secret: process_options[:secret],
-        method: "post",
-        body:
-      }
-    end
-
-    def body
-      today = Time.now.utc.strftime("%F").to_s
-
-      {
-        filter: {
-          and: [{ property: "BD_this_year", date: { equals: today } }] + 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 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_domain_services_from_notion.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./base"
-require_relative "../read/default"
-require_relative "../utils/notion/request"
-require_relative "../write/postgres"
-
-module Bot
-  ##
-  # The Bot::FetchDomainServicesFromNotion class serves as a bot implementation to read
-  # web domains 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: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "web_availability",
-  #       tag: "FetchDomainServicesFromNotion"
-  #     }
-  #   }
-  #
-  #   bot = Bot::FetchDomainServicesFromNotion.new(options)
-  #   bot.execute
-  #
-  class FetchDomainServicesFromNotion < Bot::Base
-    def read
-      reader = Read::Default.new
-
-      reader.execute
-    end
-
-    # Process function to execute the Notion utility to fetch web domains from a notion database
-    #
-    def process
-      response = Utils::Notion::Request.execute(params)
-
-      if response.code == 200
-        urls_list = normalize_response(response.parsed_response["results"])
-
-        { success: { urls: urls_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 normalize_response(results)
-      return [] if results.nil?
-
-      results.map do |value|
-        properties = value["properties"]
-
-        {
-          "url" => extract_rich_text_field_value(properties["domain"])
-        }
-      end
-    end
-
-    def extract_rich_text_field_value(data)
-      data["rich_text"][0]["plain_text"]
-    end
-  end
-end

data/lib/bas/bot/fetch_domains_wip_counts_from_notion.rb

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