bas 1.5.2 → 1.6.0

data/lib/bas/bot/fetch_domains_wip_limit_from_notion.rb

@@ -1,134 +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::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

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

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./base"
-require_relative "../read/postgres"
-require_relative "../utils/github/octokit_client"
-require_relative "../write/postgres"
-
-module Bot
-  ##
-  # The Bot::FetchGithubIssues class serves as a bot implementation to fetch GitHub issues from a
-  # repository 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: "github_issues",
-  #       tag: "FetchGithubIssues",
-  #       avoid_process: true
-  #     },
-  #     process_options: {
-  #       private_pem: "Github App private token",
-  #       app_id: "Github App id",
-  #       repo: "repository name",
-  #       filters: "hash with filters",
-  #       organization: "GitHub organization name"
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "github_issues",
-  #       tag: "GithubIssueRequest"
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "github_issues",
-  #       tag: "FetchGithubIssues"
-  #     }
-  #   }
-  #
-  #   bot = Bot::FetchGithubIssues.new(options)
-  #   bot.execute
-  #
-  class FetchGithubIssues < Bot::Base
-    ISSUE_PARAMS = %i[id html_url title body labels state created_at updated_at state].freeze
-    PER_PAGE = 100
-
-    # read function to execute the PostgresDB Read component
-    #
-    def read
-      reader = Read::Postgres.new(read_options.merge(conditions))
-
-      reader.execute
-    end
-
-    # Process function to request GitHub issues using the octokit utility
-    #
-    def process
-      octokit = Utils::Github::OctokitClient.new(params).execute
-
-      if octokit[:client]
-        repo_issues = octokit[:client].issues(@process_options[:repo], filters)
-
-        normalize_response(repo_issues).each { |issue| create_request(issue) }
-
-        { success: { created: true } }
-      else
-        { error: octokit[:error] }
-      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: "tag=$1 ORDER BY inserted_at DESC",
-        params: [read_options[:tag]]
-      }
-    end
-
-    def params
-      {
-        private_pem: process_options[:private_pem],
-        app_id: process_options[:app_id],
-        method: process_options[:method],
-        method_params: process_options[:method_params],
-        organization: process_options[:organization]
-      }
-    end
-
-    def filters
-      default_filter = { per_page: PER_PAGE }
-
-      filters = process_options[:filters]
-      filters = filters.merge({ since: read_response.inserted_at }) unless read_response.nil?
-
-      filters.is_a?(Hash) ? default_filter.merge(filters) : default_filter
-    end
-
-    def normalize_response(issues)
-      issues.map do |issue|
-        ISSUE_PARAMS.reduce({}) do |hash, param|
-          hash.merge({ param => issue.send(param) })
-              .merge({ assignees: issue.assignees.map(&:login) })
-        end
-      end
-    end
-
-    def create_request(issue)
-      write_data = {
-        success: {
-          issue:,
-          work_item_type: process_options[:work_item_type],
-          type_id: process_options[:type_id],
-          domain: process_options[:domain]
-        }
-      }
-
-      Write::Postgres.new(process_options, write_data).execute
-    end
-  end
-end

data/lib/bas/bot/fetch_images_from_discord.rb

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "./base"
-require_relative "../read/default"
-require_relative "../utils/discord/request"
-require_relative "../write/postgres"
-
-module Bot
-  ##
-  # The Bot::FetchImagesFromDiscord class serves as a bot implementation to read images
-  # from a any thread of Discord channel.
-  #
-  # <br>
-  # <b>Example</b>
-  #
-  #   options = {
-  #     process_options: {
-  #       secret_token: "discord_bot_token"
-  #       discord_channel: "discord_channel_id"
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "review_images",
-  #       tag: "FetchImagesFromDiscord"
-  #     }
-  #   }
-  #
-  #   bot = Bot::FetchImagesFromDiscord.new(options)
-  #   bot.execute
-  #
-  class FetchImagesFromDiscord < Bot::Base
-    # read function to execute the Default Read component
-    #
-    def read
-      reader = Read::Default.new
-
-      reader.execute
-    end
-
-    # Process function to execute the Discord utility to fetch images from a discord channel threads
-    #
-    def process
-      response = Utils::Discord::Request.get_thread_messages(params)
-
-      if !response.nil?
-        { success: { results: response } }
-      else
-        { error: "response is empty" }
-      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: "channels/#{process_options[:discord_channel]}/messages",
-        channel_id: process_options[:discord_channel],
-        secret_token: process_options[:secret_token],
-        method: "get",
-        body: {}
-      }
-    end
-  end
-end

data/lib/bas/bot/fetch_media_from_notion.rb

@@ -1,186 +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::FetchMediaFromNotion class serves as a bot implementation to read media (text or images)
-  # 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",
-  #       property: "paragraph"
-  #     },
-  #     write_options: {
-  #       connection: {
-  #         host: "localhost",
-  #         port: 5432,
-  #         dbname: "bas",
-  #         user: "postgres",
-  #         password: "postgres"
-  #       },
-  #       db_table: "review_media",
-  #       tag: "FetchMediaFromNotion"
-  #     }
-  #   }
-  #
-  #   bot = Bot::FetchMediaFromNotion.new(options)
-  #   bot.execute
-  #
-  class FetchMediaFromNotion < Bot::Base # rubocop:disable Metrics/ClassLength
-    CONTENT_STATUS = "review"
-
-    # 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 media from a notion database
-    #
-    def process
-      media_response = fetch_media
-
-      return media_response unless media_response[:error].nil?
-
-      { success: media_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 ORDER BY inserted_at DESC",
-        params: [false, read_options[:tag]]
-      }
-    end
-
-    def fetch_media
-      request_ids_response = fetch_requests_ids
-
-      return request_ids_response unless request_ids_response[:error].nil?
-
-      { results: fetch_pages(request_ids_response[:ids]) }
-    end
-
-    def fetch_requests_ids
-      response = Utils::Notion::Request.execute(params_database)
-
-      return error(response) unless response.code == 200
-
-      { ids: response["results"]&.map { |result| result["id"] } }
-    end
-
-    def fetch_pages(pages_ids)
-      pages_ids.map do |page_id|
-        content_response = fetch_content(page_id)
-
-        process_content(page_id, content_response)
-      end
-    end
-
-    def process_content(page_id, content)
-      return content unless content[:error].nil?
-
-      filter_media(page_id, content[:results])
-    end
-
-    def filter_media(page_id, page_content)
-      medias = page_content.select { |content| content["type"] == process_options[:property] }
-
-      media = extract_content(medias)
-      created_by = medias.first["created_by"]["id"] unless medias.first.nil?
-
-      { media:, page_id:, created_by:, property: process_options[:property] }
-    end
-
-    def extract_content(content)
-      case process_options[:property]
-      when "image" then process_images(content)
-      when "paragraph" then process_text(content)
-      end
-    end
-
-    def process_images(images)
-      images.map { |image| image["image"]["file"]["url"] }
-    end
-
-    def process_text(texts)
-      texts.reduce("") do |paragraph, text|
-        rich_text = text["paragraph"]["rich_text"].map { |plain_text| plain_text["plain_text"] }
-
-        content = rich_text.empty? ? "" : rich_text.join(" ")
-
-        "#{paragraph}\n#{content}"
-      end
-    end
-
-    def fetch_content(block_id)
-      response = fetch_block(block_id)
-
-      return error(response) unless response.code == 200
-
-      { results: response["results"] }
-    end
-
-    def error(response)
-      { error: { message: response.parsed_response, status_code: response.code } }
-    end
-
-    def params_database
-      {
-        endpoint: "databases/#{process_options[:database_id]}/query",
-        secret: process_options[:secret],
-        method: "post",
-        body: body_database
-      }
-    end
-
-    def body_database
-      { filter: { and: [] + property_condition + time_condition } }
-    end
-
-    def property_condition
-      [{ property: process_options[:property], select: { equals: CONTENT_STATUS } }]
-    end
-
-    def time_condition
-      return [] if read_response.inserted_at.nil?
-
-      [{ property: "Last edited time", last_edited_time: { on_or_after: read_response.inserted_at } }]
-    end
-
-    def fetch_block(block_id)
-      params = block_params(block_id)
-
-      Utils::Notion::Request.execute(params)
-    end
-
-    def block_params(block_id)
-      {
-        endpoint: "blocks/#{block_id}/children",
-        secret: process_options[:secret],
-        method: "get",
-        body: {}
-      }
-    end
-  end
-end