bns 0.1.0

data/lib/bns/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 Exceptions::Discord::InvalidWebookToken, response.message
+        else
+          response
+        end
+      end
+    end
+  end
+end

data/lib/bns/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/bns/domain/birthday.rb

@@ -0,0 +1,23 @@
+# 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
+
+    # 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/bns/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/bns/domain/pto.rb

@@ -0,0 +1,26 @@
+# 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
+
+    # 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/bns/fetcher/base.rb

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

data/lib/bns/fetcher/notion/birthday.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "date"
+
+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 birthday data from Notion.
+    #
+    class Birthday < Base
+      # Implements the data fetching logic for Birthdays 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 fetch
+        url = build_url(config[:base_url], config[:database_id])
+
+        httparty_response = HTTParty.post(url, { body: config[: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
+
+      def build_url(base, database_id)
+        "#{base}/v1/databases/#{database_id}/query"
+      end
+    end
+  end
+end

data/lib/bns/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/bns/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/bns/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/bns/fetcher/notion/pto.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "httparty"
+require "date"
+
+require_relative "../base"
+require_relative "./exceptions/invalid_api_key"
+require_relative "./exceptions/invalid_database_id"
+require_relative "./types/response"
+
+module Fetcher
+  module Notion
+    ##
+    # This class is an implementation of the Fetcher::Base interface, specifically designed
+    # for fetching Paid Time Off (PTO) data from Notion.
+    #
+    class Pto < Base
+      # Implements the data fetching logic for PTO's 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 fetch
+        url = "#{config[:base_url]}/v1/databases/#{config[:database_id]}/query"
+
+        httparty_response = HTTParty.post(url, { body: config[: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/bns/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 = nil
+          else
+            @status_code = 200
+            @message = "success"
+            @results = response["results"]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bns/formatter/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../domain/exceptions/function_not_implemented"
+
+module Formatter
+  ##
+  # The Formatter::Base module serves as the foundation for implementing specific data presentation logic
+  # within the Formatter module. Defines essential methods, that provide a blueprint for creating custom
+  # formatters tailored to different use cases.
+  #
+  module Base
+    # A method meant to give an specified format depending on the implementation to the data coming from an
+    # implementation of the Mapper::Base interface.
+    # Must be overridden by subclasses, with specific logic based on the use case.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>List<Domain::></tt> domain_data: List of specific domain objects depending on the use case.
+    #
+    # <br>
+    # <b>raises</b> <tt>Domain::Exceptions::FunctionNotImplemented</tt> when missing implementation.
+    #
+    # <b>returns</b> <tt>String</tt> Formatted payload suitable for a Dispatcher::Base implementation.
+    #
+    def format(_domain_data)
+      raise Domain::Exceptions::FunctionNotImplemented
+    end
+  end
+end

data/lib/bns/formatter/discord/birthday.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "../../domain/birthday"
+require_relative "../base"
+require_relative "./exceptions/invalid_data"
+
+module Formatter
+  module Discord
+    ##
+    # This class implementats the methods of the Formatter::Base module, specifically designed for formatting birthday
+    # data in a way suitable for Discord messages.
+    class Birthday
+      include Base
+
+      # Implements the logic for building a formatted payload with the given template for birthdays.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>List<Domain::Birthday></tt> birthdays_list: list of mapped birthdays.
+      #
+      # <br>
+      # <b>raises</b> <tt>Formatter::Discord::Exceptions::InvalidData</tt> when invalid data is provided.
+      #
+      # <br>
+      # <b>returns</b> <tt>String</tt> payload: formatted payload suitable for a Discord message.
+      #
+      def format(birthdays_list)
+        raise Formatter::Discord::Exceptions::InvalidData unless birthdays_list.all? do |brithday|
+                                                                   brithday.is_a?(Domain::Birthday)
+                                                                 end
+
+        template = "NAME, Wishing you a very happy birthday! Enjoy your special day! :birthday: :gift:"
+        payload = ""
+
+        birthdays_list.each do |birthday|
+          payload += "#{template.gsub("NAME", birthday.individual_name)}\n"
+        end
+
+        payload
+      end
+    end
+  end
+end

data/lib/bns/formatter/discord/exceptions/invalid_data.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Formatter
+  module Discord
+    module Exceptions
+      ##
+      # Provides a domain-specific representation for errors that occurs when trying to process invalid
+      # data on a Fetcher::Base implementation
+      #
+      class InvalidData < StandardError
+        def initialize(message = "")
+          super(message)
+        end
+      end
+    end
+  end
+end

data/lib/bns/formatter/discord/pto.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "../../domain/pto"
+require_relative "../base"
+
+module Formatter
+  module Discord
+    ##
+    # This class is an implementation of the Formatter::Base interface, specifically designed for formatting PTO
+    # data in a way suitable for Discord messages.
+    class Pto
+      include Base
+
+      # Implements the logic for building a formatted payload with the given template for PTO's.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>List<Domain::Pto></tt> pto_list: List of mapped PTO's.
+      #
+      # <br>
+      # <b>raises</b> <tt>Formatter::Discord::Exceptions::InvalidData</tt> when invalid data is provided.
+      #
+      # <br>
+      # <b>returns</b> <tt>String</tt> payload, formatted payload suitable for a Discord message.
+      #
+      def format(ptos_list)
+        raise Formatter::Discord::Exceptions::InvalidData unless ptos_list.all? { |pto| pto.is_a?(Domain::Pto) }
+
+        template = ":beach: NAME is on PTO"
+        payload = ""
+
+        ptos_list.each do |pto|
+          payload += "#{template.gsub("NAME", pto.individual_name)} #{build_pto_message(pto)}\n"
+        end
+
+        payload
+      end
+
+      private
+
+      def build_pto_message(pto)
+        if pto.start_date.include?("|")
+          start_time = pto.start_date.split("|")
+          end_time = pto.end_date.split("|")
+          "#{start_time[1]} - #{end_time[1]}"
+        else
+          "all day"
+        end
+      end
+    end
+  end
+end

data/lib/bns/mapper/base.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../domain/exceptions/function_not_implemented"
+
+module Mapper
+  ##
+  # The Mapper::Base module serves as the foundation for implementing specific data shaping logic within the
+  # Mapper module. Defines essential methods, that provide a blueprint for organizing or shaping data in a manner
+  # suitable for downstream formatting processes.
+  #
+  module Base
+    # An method meant to prepare or organize the data coming from an implementation of the Fetcher::Base interface.
+    # Must be overridden by subclasses, with specific logic based on the use case.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>Fetcher::Notion::Types::Response</tt> response: Response produced by a fetcher.
+    #
+    # <br>
+    #
+    # <b>raises</b> <tt>Domain::Exceptions::FunctionNotImplemented</tt> when missing implementation.
+    # <br>
+    #
+    # <b>returns</b> <tt>List<Domain::></tt> Mapped list of data, ready to be formatted.
+    #
+    def map(_response)
+      raise Domain::Exceptions::FunctionNotImplemented
+    end
+  end
+end

data/lib/bns/mapper/notion/birthday.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative "../../domain/birthday"
+require_relative "../base"
+
+module Mapper
+  module Notion
+    ##
+    # This class implementats the methods of the Mapper::Base module, specifically designed for preparing or
+    # shaping birthdays data coming from a Fetcher::Base implementation.
+    class Birthday
+      include Base
+
+      # Implements the logic for shaping the results from a fetcher response.
+      #
+      # <br>
+      # <b>Params:</b>
+      # * <tt>Fetcher::Notion::Types::Response</tt> notion_response: Notion response object.
+      #
+      # <br>
+      # <b>return</b> <tt>List<Domain::Birthday></tt> birthdays_list, mapped birthdays to be used by a
+      # Formatter::Base implementation.
+      #
+      def map(notion_response)
+        return [] if notion_response.results.empty?
+
+        normalized_notion_data = normalize_response(notion_response.results)
+
+        normalized_notion_data.map do |birthday|
+          Domain::Birthday.new(birthday["name"], birthday["birth_date"])
+        end
+      end
+
+      private
+
+      def normalize_response(results)
+        return [] if results.nil?
+
+        normalized_results = []
+
+        results.map do |value|
+          properties = value["properties"]
+          properties.delete("Name")
+
+          normalized_value = normalize(properties)
+
+          normalized_results.append(normalized_value)
+        end
+
+        normalized_results
+      end
+
+      def normalize(properties)
+        normalized_value = {}
+
+        properties.each do |k, v|
+          if k == "Complete Name"
+            normalized_value["name"] = extract_rich_text_field_value(v)
+          elsif k == "BD_this_year"
+            normalized_value["birth_date"] = extract_date_field_value(v)
+          end
+        end
+
+        normalized_value
+      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
+end