bas 0.1.0

data/lib/bas/dispatcher/base.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "../domain/exceptions/function_not_implemented"
+
+module Dispatcher
+  ##
+  # Serves as a foundational structure for implementing specific dispatchers. Acting as an interface,
+  # this class defines essential attributes and methods, providing a blueprint for creating custom
+  # dispatchers tailored to different platforms or services.
+  #
+  class Base
+    attr_reader :webhook, :name
+
+    # Initializes the dispatcher with essential configuration parameters.
+    #
+    def initialize(config)
+      @webhook = config[:webhook]
+      @name = config[:name]
+    end
+
+    # A method meant to send messages to an specific destination depending on the implementation.
+    # Must be overridden by subclasses, with specific logic based on the use case.
+    #
+    # <br>
+    # <b>returns</b> a <tt>Discord::Response</tt>
+    #
+    def dispatch(_payload)
+      raise Domain::Exceptions::FunctionNotImplemented
+    end
+  end
+end

data/lib/bas/dispatcher/discord/exceptions/invalid_webhook_token.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Dispatcher
+  module Discord
+    module Exceptions
+      ##
+      # Domain specific representation  when an invalid Discord webhook token is provided to Discord.
+      #
+      class InvalidWebookToken < StandardError
+        def initialize(message = "The provided Webhook token is invalid.")
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/bas/dispatcher/discord/implementation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "./exceptions/invalid_webhook_token"
+require_relative "./types/response"
+
+module Dispatcher
+  module Discord
+    ##
+    # This class is an implementation of the Dispatcher::Base interface, specifically designed
+    # for dispatching messages to Discord.
+    #
+    class Implementation < Base
+      # Implements the dispatching logic for the Discord use case. It sends a POST request to
+      # the Discord webhook with the specified payload.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>String</tt> payload: Payload to be dispatched to discord.
+      # <br>
+      # <b>raises</b> <tt>Exceptions::Discord::InvalidWebookToken</tt> if the provided webhook token is invalid.
+      #
+      # <br>
+      # <b>returns</b> <tt>Dispatcher::Discord::Types::Response</tt>
+      #
+      def dispatch(payload)
+        body = {
+          username: name,
+          avatar_url: "",
+          content: payload
+        }.to_json
+        response = HTTParty.post(webhook, { body: body, headers: { "Content-Type" => "application/json" } })
+
+        discord_response = Dispatcher::Discord::Types::Response.new(response)
+
+        validate_response(discord_response)
+      end
+
+      private
+
+      def validate_response(response)
+        case response.code
+        when 50_027
+          raise Discord::Exceptions::InvalidWebookToken, response.message
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/bas/dispatcher/discord/types/response.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Dispatcher
+  module Discord
+    module Types
+      ##
+      # Represents a response received from Discord. It encapsulates essential information about the response,
+      # providing a structured way to handle and analyze Discord server responses.
+      #
+      class Response
+        attr_reader :code, :http_code, :message, :response
+
+        def initialize(response)
+          @http_code = response.code
+          @code = response["code"]
+          @message = response.message
+          @response = response.response
+        end
+      end
+    end
+  end
+end

data/lib/bas/dispatcher/slack/exceptions/invalid_webhook_token.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Dispatcher
+  module Slack
+    module Exceptions
+      ##
+      # Domain specific representation when an invalid webhook token is provided to Slack.
+      #
+      class InvalidWebookToken < StandardError
+        def initialize(message = "The provided Webhook token is invalid.")
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/bas/dispatcher/slack/implementation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+require_relative "./exceptions/invalid_webhook_token"
+require_relative "./types/response"
+
+module Dispatcher
+  module Slack
+    ##
+    # This class is an implementation of the Dispatcher::Base interface, specifically designed
+    # for dispatching messages to Slack.
+    #
+    class Implementation < Base
+      # Implements the dispatching logic for the Slack use case. It sends a POST request to
+      # the Slack webhook with the specified payload.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>String</tt> payload: Payload to be dispatched to slack.
+      # <br>
+      # <b>raises</b> <tt>Exceptions::Slack::InvalidWebookToken</tt> if the provided webhook token is invalid.
+      #
+      # <br>
+      # <b>returns</b> <tt>Dispatcher::Slack::Types::Response</tt>
+      #
+      def dispatch(payload)
+        body = {
+          username: name,
+          text: payload
+        }.to_json
+
+        response = HTTParty.post(webhook, { body: body, headers: { "Content-Type" => "application/json" } })
+
+        slack_response = Dispatcher::Discord::Types::Response.new(response)
+
+        validate_response(slack_response)
+      end
+
+      private
+
+      def validate_response(response)
+        case response.http_code
+        when 403
+          raise Dispatcher::Slack::Exceptions::InvalidWebookToken, response.message
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/bas/dispatcher/slack/types/response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Dispatcher
+  module Slack
+    module Types
+      ##
+      # Represents a response received from Slack. It encapsulates essential information about the response,
+      # providing a structured way to handle and analyze Slack server responses.
+      #
+      class Response
+        attr_reader :body, :http_code, :message
+
+        def initialize(response)
+          @http_code = response.code
+          @message = response.message
+          @body = response.body
+        end
+      end
+    end
+  end
+end

data/lib/bas/domain/birthday.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Domain
+  ##
+  # The Domain::Birthday class provides a domain-specific representation of a Birthday object.
+  # It encapsulates the individual's name and their birthdate, offering a structured way to
+  # handle and manipulate birthday information.
+  class Birthday
+    attr_reader :individual_name, :birth_date
+
+    ATTRIBUTES = %w[individual_name birth_date].freeze
+
+    # Initializes a Domain::Birthday instance with the specified individual name, and date of birth.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>String</tt> individual_name Name of the individual
+    # * <tt>Date</tt> birth_date Birthdate from the individual
+    #
+    def initialize(individual_name, date)
+      @individual_name = individual_name
+      @birth_date = date
+    end
+  end
+end

data/lib/bas/domain/email.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Domain
+  ##
+  # The Domain::Email class provides a domain-specific representation of an Email object.
+  # It encapsulates information about an email, including the subject, the sender, and the date.
+  #
+  class Email
+    attr_reader :subject, :sender
+    attr_accessor :date
+
+    ATTRIBUTES = %w[subject sender date].freeze
+
+    # Initializes a Domain::Email instance with the specified subject, sender, and date.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>String</tt> email subject.
+    # * <tt>String</tt> Email of the sender.
+    # * <tt>String</tt> Reception date
+    #
+    def initialize(subject, sender, date)
+      @subject = subject
+      @sender = sender
+      @date = parse_to_datetime(date)
+    end
+
+    private
+
+    def parse_to_datetime(date)
+      DateTime.parse(date).to_time
+    end
+  end
+end

data/lib/bas/domain/exceptions/function_not_implemented.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Domain
+  module Exceptions
+    ##
+    # Provides a domain-specific representation for errors that occur when a function has not been implemented yet.
+    # It inherits from StandardError # and allows developers to raise a specific exception when a required function
+    # remains unimplemented in a subclass.
+    #
+    class FunctionNotImplemented < StandardError
+      # Initializes the exception with an optional custom error message.
+      #
+      def initialize(message = "The function haven't been implemented yet.")
+        super(message)
+      end
+    end
+  end
+end

data/lib/bas/domain/pto.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Domain
+  ##
+  # The Domain::Pto class provides a domain-specific representation of a Paid Time Off (PTO) object.
+  # It encapsulates information about an individual's time off, including the individual's name,
+  # the start date, and the end date of the time off period.
+  #
+  class Pto
+    attr_reader :individual_name, :start_date, :end_date
+
+    ATTRIBUTES = %w[individual_name start_date end_date].freeze
+
+    # Initializes a Domain::Pto instance with the specified individual name, start date, and end date.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>String</tt> individual_name Name of the individual.
+    # * <tt>DateTime</tt> start_date Start day of the PTO.
+    # * <tt>String</tt> end_date End date of the PTO.
+    #
+    def initialize(individual_name, start_date, end_date)
+      @individual_name = individual_name
+      @start_date = start_date
+      @end_date = end_date
+    end
+  end
+end

data/lib/bas/domain/work_items_limit.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Domain
+  ##
+  # The Domain::WorkItemsLimit class provides a domain-specific representation of a Work Item object.
+  # It encapsulates information about a work items limit, including the domain and total.
+  #
+  class WorkItemsLimit
+    attr_reader :domain, :total
+
+    ATTRIBUTES = %w[domain total].freeze
+
+    # Initializes a Domain::WorkItemsLimit instance with the specified domain and total.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>String</tt> 'domain' responsible domain of the work items.
+    # * <tt>String</tt> 'total' total 'in progress' work items.
+    #
+    def initialize(domain, total)
+      @domain = domain
+      @total = total
+    end
+  end
+end

data/lib/bas/fetcher/base.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../domain/exceptions/function_not_implemented"
+
+module Fetcher
+  ##
+  # The Fetcher::Base class serves as the foundation for implementing specific data fetchers within the Fetcher module.
+  # Operating as an interface, this class defines essential attributes and methods, providing a blueprint for creating
+  # custom fetchers tailored to different data sources.
+  #
+  class Base
+    attr_reader :config
+
+    # Initializes the fetcher with essential configuration parameters.
+    #
+    def initialize(config)
+      @config = config
+    end
+
+    # A method meant to fetch data from an specific source depending on the implementation.
+    # Must be overridden by subclasses, with specific logic based on the use case.
+    #
+    # <br>
+    # <b>raises</b> <tt>Domain::Exceptions::FunctionNotImplemented</tt> when missing implementation.
+    #
+    def fetch
+      raise Domain::Exceptions::FunctionNotImplemented
+    end
+
+    protected
+
+    # A method meant to execute the fetch request, retrieven the required data
+    # from an specific filter configuration depending on the use case implementation.
+    # Must be overridden by subclasses, with specific logic based on the use case.
+    #
+    # <br>
+    # <b>raises</b> <tt>Domain::Exceptions::FunctionNotImplemented</tt> when missing implementation.
+    #
+    def execute
+      raise Domain::Exceptions::FunctionNotImplemented
+    end
+  end
+end

data/lib/bas/fetcher/imap/base.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "net/imap"
+require "gmail_xoauth"
+
+require_relative "../base"
+require_relative "./types/response"
+
+module Fetcher
+  module Imap
+    ##
+    # This class is an implementation of the Fetcher::Base interface, specifically designed
+    # for fetching data from an IMAP server.
+    #
+    class Base < Fetcher::Base
+      protected
+
+      # Implements the data fetching logic for emails data from an IMAP server.
+      # It connects to an IMAP server inbox, request emails base on a filter,
+      # and returns a validated response.
+      #
+      def execute(email_domain, email_port, token_uri, query)
+        access_token = refresh_token(token_uri)
+
+        imap_fetch(email_domain, email_port, query, access_token)
+
+        Fetcher::Imap::Types::Response.new(@emails)
+      end
+
+      private
+
+      def imap_fetch(email_domain, email_port, query, access_token)
+        imap = Net::IMAP.new(email_domain, port: email_port, ssl: true)
+
+        imap.authenticate("XOAUTH2", config[:user], access_token)
+
+        imap.examine(config[:inbox])
+
+        @emails = fetch_emails(imap, query)
+
+        imap.logout
+        imap.disconnect
+      end
+
+      def fetch_emails(imap, query)
+        imap.search(query).map do |message_id|
+          imap.fetch(message_id, "ENVELOPE")[0].attr["ENVELOPE"]
+        end
+      end
+
+      def refresh_token(token_uri)
+        uri = URI.parse(token_uri)
+
+        response = Net::HTTP.post_form(uri, params)
+        token_data = JSON.parse(response.body)
+
+        token_data["access_token"]
+      end
+
+      def params
+        {
+          "grant_type" => "refresh_token",
+          "refresh_token" => config[:refresh_token],
+          "client_id" => config[:client_id],
+          "client_secret" => config[:client_secret]
+        }
+      end
+    end
+  end
+end

data/lib/bas/fetcher/imap/types/response.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Fetcher
+  module Imap
+    module Types
+      ##
+      # Represents a response received from the Imap client. It encapsulates essential
+      # information about the response, providing a structured way to handle and analyze
+      # it's responses.
+      class Response
+        attr_reader :status_code, :message, :results
+
+        def initialize(response)
+          if response.empty?
+            @status_code = 404
+            @message = "no result were found"
+            @results = []
+          else
+            @status_code = 200
+            @message = "success"
+            @results = response
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bas/fetcher/imap/use_case/support_emails.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Imap
+    ##
+    # This class is an implementation of the Fetcher::Imap::Base interface, specifically designed
+    # for fetching support email from a Google Gmail account.
+    #
+    class SupportEmails < Imap::Base
+      TOKEN_URI = "https://oauth2.googleapis.com/token"
+      EMAIL_DOMAIN = "imap.gmail.com"
+      EMAIL_PORT = 993
+
+      # Implements the data fetching filter for support emails from Google Gmail.
+      #
+      def fetch
+        yesterday = (Time.now - (60 * 60 * 24)).strftime("%e-%b-%Y")
+        query = ["TO", config[:search_email], "SINCE", yesterday]
+
+        execute(EMAIL_DOMAIN, EMAIL_PORT, TOKEN_URI, query)
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "httparty"
+
+require_relative "../base"
+require_relative "./exceptions/invalid_api_key"
+require_relative "./exceptions/invalid_database_id"
+require_relative "./types/response"
+require_relative "./helper"
+
+module Fetcher
+  module Notion
+    ##
+    # This class is an implementation of the Fetcher::Base interface, specifically designed
+    # for fetching data from Notion.
+    #
+    class Base < Fetcher::Base
+      NOTION_BASE_URL = "https://api.notion.com"
+
+      protected
+
+      # Implements the data fetching logic for data from Notion. It sends a POST
+      # request to the Notion API to query the specified database and returns a validated response.
+      #
+      # <br>
+      # <b>raises</b> <tt>Exceptions::Notion::InvalidApiKey</tt> if the API key provided is incorrect or invalid.
+      #
+      # <b>raises</b> <tt>Exceptions::Notion::InvalidDatabaseId</tt> if the Database id provided is incorrect
+      # or invalid.
+      #
+      def execute(filter)
+        url = "#{NOTION_BASE_URL}/v1/databases/#{config[:database_id]}/query"
+
+        httparty_response = HTTParty.post(url, { body: filter.to_json, headers: headers })
+
+        notion_response = Fetcher::Notion::Types::Response.new(httparty_response)
+
+        Fetcher::Notion::Helper.validate_response(notion_response)
+      end
+
+      private
+
+      def headers
+        {
+          "Authorization" => "Bearer #{config[:secret]}",
+          "Content-Type" => "application/json",
+          "Notion-Version" => "2022-06-28"
+        }
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/exceptions/invalid_api_key.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Exceptions
+  module Notion
+    ##
+    # Provides a domain-specific representation for errors that occurs when an invalid API key is provided
+    # for a Notion-related operation.
+    #
+    class InvalidApiKey < StandardError
+      def initialize(message = "The provided API token is invalid.")
+        super(message)
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/exceptions/invalid_database_id.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Exceptions
+  module Notion
+    ##
+    # Provides a domain-specific representation for errors that occurs when an invalid database id is provided
+    # for a Notion-related operation.
+    #
+    class InvalidDatabaseId < StandardError
+      def initialize(message = "The provided id doesn't match any database.")
+        super(message)
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/helper.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Fetcher
+  module Notion
+    ##
+    # Provides common fuctionalities along the Notion domain.
+    #
+    module Helper
+      def self.validate_response(response)
+        case response.status_code
+        when 401
+          raise Exceptions::Notion::InvalidApiKey, response.message
+        when 404
+          raise Exceptions::Notion::InvalidDatabaseId, response.message
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/types/response.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Fetcher
+  module Notion
+    module Types
+      ##
+      # Represents a response received from the Notion API. It encapsulates essential information about the response,
+      # providing a structured way to handle and analyze it's responses.
+      class Response
+        attr_reader :status_code, :message, :results
+
+        def initialize(response)
+          if response["results"].nil?
+            @status_code = response["status"]
+            @message = response["message"]
+            @results = []
+          else
+            @status_code = 200
+            @message = "success"
+            @results = response["results"]
+          end
+        end
+      end
+    end
+  end
+end