bas 0.1.0

data/lib/bas/fetcher/notion/use_case/birthday_next_week.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Notion
+    ##
+    # This class is an implementation of the Fetcher::Notion::Base interface, specifically designed
+    # for fetching next week birthdays data from Notion.
+    #
+    class BirthdayNextWeek < Notion::Base
+      DAYS_BEFORE_NOTIFY = 8
+
+      # Implements the data fetching filter for next week Birthdays data from Notion.
+      #
+      def fetch
+        filter = {
+          filter: {
+            or: [
+              { property: "BD_this_year", date: { equals: eight_days_from_now } }
+            ]
+          }
+        }
+
+        execute(filter)
+      end
+
+      private
+
+      def eight_days_from_now
+        date = Time.now.utc + days_in_second(DAYS_BEFORE_NOTIFY)
+
+        date.utc.strftime("%F").to_s
+      end
+
+      def days_in_second(days)
+        days * 24 * 60 * 60
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/use_case/birthday_today.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Notion
+    ##
+    # This class is an implementation of the Fetcher::Notion::Base interface, specifically designed
+    # for fetching birthday data from Notion.
+    #
+    class BirthdayToday < Notion::Base
+      # Implements the data fetching filter for todays Birthdays data from Notion.
+      #
+      def fetch
+        today = Time.now.utc.strftime("%F").to_s
+
+        filter = {
+          filter: {
+            or: [
+              { property: "BD_this_year", date: { equals: today } }
+            ]
+          }
+        }
+
+        execute(filter)
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/use_case/pto_next_week.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Notion
+    ##
+    # This class is an implementation of the Fetcher::Notion::Base interface, specifically designed
+    # for fetching next week Paid Time Off (PTO) data from Notion.
+    #
+    class PtoNextWeek < Notion::Base
+      # Implements the data fetching filter for next week PTO's data from Notion.
+      #
+      def fetch
+        filter = build_filter
+
+        execute(filter)
+      end
+
+      private
+
+      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 build_filter
+        monday, sunday = next_week_dates
+
+        {
+          filter: {
+            or: [
+              belong_next_week("Desde?", monday, sunday),
+              belong_next_week("Hasta?", monday, sunday),
+              cover_next_week(monday, sunday)
+            ]
+          }
+        }
+      end
+
+      def belong_next_week(property, after_day, before_day)
+        {
+          and: [
+            { property: property, date: { on_or_after: after_day } },
+            { property: property, date: { on_or_before: before_day } }
+          ]
+        }
+      end
+
+      def cover_next_week(monday, sunday)
+        {
+          and: [
+            { property: "Hasta?", date: { on_or_after: sunday } },
+            { property: "Desde?", date: { on_or_before: monday } }
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/use_case/pto_today.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Notion
+    ##
+    # This class is an implementation of the Fetcher::Notion::Base interface, specifically designed
+    # for fetching Paid Time Off (PTO) data from Notion.
+    #
+    class PtoToday < Notion::Base
+      # Implements the data fetching filter for todays PTO's data from Notion.
+      #
+      def fetch
+        today = Time.now.utc.strftime("%F").to_s
+
+        filter = {
+          filter: {
+            "and": [
+              { property: "Desde?", date: { on_or_before: today } },
+              { property: "Hasta?", date: { on_or_after: today } }
+            ]
+          }
+        }
+
+        execute(filter)
+      end
+    end
+  end
+end

data/lib/bas/fetcher/notion/use_case/work_items_limit.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Notion
+    ##
+    # This class is an implementation of the Fetcher::Notion::Base interface, specifically designed
+    # for counting "in progress" work items from work item database in Notion.
+    #
+    class WorkItemsLimit < Notion::Base
+      # Implements the data fetching count of "in progress" work items from Notion.
+      #
+      def fetch
+        filter = {
+          filter: {
+            "and": [
+              { property: "OK", formula: { string: { contains: "✅" } } },
+              { "or": status_conditions }
+            ]
+          }
+        }
+
+        execute(filter)
+      end
+
+      private
+
+      def status_conditions
+        [
+          { property: "Status", status: { equals: "In Progress" } },
+          { property: "Status", status: { equals: "On Hold" } }
+        ]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "pg"
+
+require_relative "../base"
+require_relative "./types/response"
+require_relative "./helper"
+
+module Fetcher
+  module Postgres
+    ##
+    # This class is an implementation of the Fetcher::Base interface, specifically designed
+    # for fetching data from Postgres.
+    #
+    class Base < Fetcher::Base
+      protected
+
+      # Implements the data fetching logic from a Postgres database. It use the PG gem
+      # to request data from a local or external database and returns a validated response.
+      #
+      # Gem: pg (https://rubygems.org/gems/pg)
+      #
+      def execute(query)
+        pg_connection = PG::Connection.new(config[:connection])
+
+        pg_result = execute_query(pg_connection, query)
+
+        postgres_response = Fetcher::Postgres::Types::Response.new(pg_result)
+
+        Fetcher::Postgres::Helper.validate_response(postgres_response)
+      end
+
+      private
+
+      def execute_query(pg_connection, query)
+        if query.is_a? String
+          pg_connection.exec(query)
+        else
+          sentence, params = query
+
+          pg_connection.exec_params(sentence, params)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Fetcher
+  module Postgres
+    ##
+    # Provides common fuctionalities along the Postgres domain.
+    #
+    module Helper
+      def self.validate_response(response)
+        response.response.check_result
+
+        response
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Fetcher
+  module Postgres
+    module Types
+      ##
+      # Represents a response received from the Postgres API. It encapsulates essential information about the response,
+      # providing a structured way to handle and analyze it's responses.
+      class Response
+        attr_reader :status, :message, :response, :fields, :records
+
+        SUCCESS_STATUS = "PGRES_TUPLES_OK"
+
+        def initialize(response)
+          if response.res_status == SUCCESS_STATUS
+            success_response(response)
+          else
+            failure_response(response)
+          end
+        end
+
+        private
+
+        def success_response(response)
+          @status = response.res_status
+          @message = "success"
+          @response = response
+          @fields = response.fields
+          @records = response.values
+        end
+
+        def failure_response(response)
+          @status = response.res_status
+          @message = response.result_error_message
+          @response = response
+          @fields = nil
+          @records = nil
+        end
+      end
+    end
+  end
+end

data/lib/bas/fetcher/postgres/use_case/pto_today.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative "../base"
+
+module Fetcher
+  module Postgres
+    ##
+    # This class is an implementation of the Fetcher::Postgres::Base interface, specifically designed
+    # for fetching Paid Time Off (PTO) data from a Postgres Database.
+    #
+    class PtoToday < Base
+      # Implements the data fetching query for todays PTO data from a Postgres database.
+      #
+      def fetch
+        execute(build_query)
+      end
+
+      private
+
+      def build_query
+        today = Time.now.utc.strftime("%F").to_s
+
+        start_time = "#{today}T00:00:00"
+        end_time = "#{today}T23:59:59"
+
+        where = "(start_date <= $1 AND end_date >= $1) OR (start_date>= $2 AND end_date <= $3)"
+
+        ["SELECT * FROM pto WHERE #{where}", [today, start_time, end_time]]
+      end
+    end
+  end
+end

data/lib/bas/formatter/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../domain/exceptions/function_not_implemented"
+require "erb"
+
+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.
+  #
+  class Base
+    attr_reader :template
+
+    # Initializes the fetcher with essential configuration parameters.
+    #
+    def initialize(config = {})
+      @config = config
+      @template = config[:template]
+    end
+
+    # This method is designed to provide a specified format for data from any 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
+
+    protected
+
+    def build_template(attributes, instance)
+      formated_template = format_template(attributes, instance)
+
+      "#{ERB.new(formated_template).result(binding)}\n"
+    end
+
+    def format_template(attributes, _instance)
+      attributes.reduce(template) do |formated_template, attribute|
+        formated_template.gsub(attribute, "<%= instance.#{attribute} %>")
+      end
+    end
+  end
+end

data/lib/bas/formatter/birthday.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "../domain/birthday"
+require_relative "./exceptions/invalid_data"
+require_relative "./base"
+
+module Formatter
+  ##
+  # This class implements methods from the Formatter::Base module, tailored to format the
+  # Domain::Birthday structure for a dispatcher.
+  class Birthday < 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::Exceptions::InvalidData</tt> when invalid data is provided.
+    #
+    # <br>
+    # <b>returns</b> <tt>String</tt> payload: formatted payload suitable for a Dispatcher.
+    #
+    def format(birthdays_list)
+      raise Formatter::Exceptions::InvalidData unless birthdays_list.all? do |brithday|
+        brithday.is_a?(Domain::Birthday)
+      end
+
+      birthdays_list.reduce("") do |payload, birthday|
+        payload + build_template(Domain::Birthday::ATTRIBUTES, birthday)
+      end
+    end
+  end
+end

data/lib/bas/formatter/exceptions/invalid_data.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Formatter
+  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

data/lib/bas/formatter/pto.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "date"
+
+require_relative "../domain/pto"
+require_relative "./exceptions/invalid_data"
+require_relative "./base"
+
+module Formatter
+  ##
+  # This class implements methods from the Formatter::Base module, tailored to format the
+  # Domain::Pto structure for a dispatcher.
+  class Pto < Base
+    DEFAULT_TIME_ZONE = "+00:00"
+
+    # Initializes the Slack formatter with essential configuration parameters.
+    #
+    # <b>timezone</b> : expect an string with the time difference relative to the UTC. Example: "-05:00"
+    def initialize(config = {})
+      super(config)
+
+      @timezone = config[:timezone] || DEFAULT_TIME_ZONE
+    end
+
+    # 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::Exceptions::InvalidData</tt> when invalid data is provided.
+    #
+    # <br>
+    # <b>returns</b> <tt>String</tt> payload, formatted payload suitable for a Dispatcher.
+    #
+
+    def format(ptos_list)
+      raise Formatter::Exceptions::InvalidData unless ptos_list.all? { |pto| pto.is_a?(Domain::Pto) }
+
+      ptos_list.reduce("") do |payload, pto|
+        built_template = build_template(Domain::Pto::ATTRIBUTES, pto)
+        payload + format_message_by_case(built_template.gsub("\n", ""), pto)
+      end
+    end
+
+    private
+
+    def format_message_by_case(built_template, pto)
+      date_start = format_timezone(pto.start_date).strftime("%F")
+      date_end = format_timezone(pto.end_date).strftime("%F")
+
+      if date_start == date_end
+        interval = same_day_interval(pto)
+        day_message = today?(date_start) ? "today" : "the day #{date_start}"
+
+        "#{built_template} #{day_message} #{interval}\n"
+      else
+        "#{built_template} from #{date_start} to #{date_end}\n"
+      end
+    end
+
+    def same_day_interval(pto)
+      time_start = format_timezone(pto.start_date).strftime("%I:%M %P")
+      time_end = format_timezone(pto.end_date).strftime("%I:%M %P")
+
+      time_start == time_end ? "all day" : "from #{time_start} to #{time_end}"
+    end
+
+    def format_timezone(date)
+      date_time = build_date(date)
+
+      Time.at(date_time, in: @timezone)
+    end
+
+    def today?(date)
+      time_now = Time.now.strftime("%F")
+
+      date == format_timezone(time_now).strftime("%F")
+    end
+
+    def build_date(date)
+      date_time = date.include?("T") ? date : "#{date}T00:00:00.000#{@timezone}"
+
+      DateTime.parse(date_time).to_time
+    end
+  end
+end

data/lib/bas/formatter/support_emails.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "../domain/email"
+require_relative "./exceptions/invalid_data"
+require_relative "./base"
+
+module Formatter
+  ##
+  # This class implements methods from the Formatter::Base module, tailored to format the
+  # Domain::Email structure for a dispatcher.
+  class SupportEmails < Base
+    DEFAULT_TIME_ZONE = "+00:00"
+
+    # Initializes the formatter with essential configuration parameters.
+    #
+    # <b>timezone</b> : expect an string with the time difference relative to the UTC. Example: "-05:00"
+    def initialize(config = {})
+      super(config)
+
+      @timezone = config[:timezone] || DEFAULT_TIME_ZONE
+      @frecuency = config[:frecuency]
+    end
+
+    # Implements the logic for building a formatted payload with the given template for support emails.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>List<Domain::Email></tt> support_emails_list: list of support emails.
+    #
+    # <br>
+    # <b>raises</b> <tt>Formatter::Exceptions::InvalidData</tt> when invalid data is provided.
+    #
+    # <br>
+    # <b>returns</b> <tt>String</tt> payload: formatted payload suitable for a Dispatcher.
+    #
+    def format(support_emails_list)
+      raise Formatter::Exceptions::InvalidData unless support_emails_list.all? do |support_email|
+        support_email.is_a?(Domain::Email)
+      end
+
+      process_emails(support_emails_list).reduce("") do |payload, support_email|
+        payload + build_template(Domain::Email::ATTRIBUTES, support_email)
+      end
+    end
+
+    private
+
+    def process_emails(emails)
+      emails.each { |email| email.date = at_timezone(email.date) }
+      emails.filter! { |email| email.date > time_window } unless @frecuency.nil?
+
+      format_timestamp(emails)
+    end
+
+    def format_timestamp(emails)
+      emails.each { |email| email.date = email.date.strftime("%F %r") }
+    end
+
+    def time_window
+      date_time = Time.now - (60 * 60 * @frecuency)
+
+      at_timezone(date_time)
+    end
+
+    def at_timezone(date)
+      Time.at(date, in: @timezone)
+    end
+  end
+end

data/lib/bas/formatter/work_items_limit.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative "../domain/work_items_limit"
+require_relative "./exceptions/invalid_data"
+require_relative "./base"
+
+module Formatter
+  ##
+  # This class implements methods from the Formatter::Base module, tailored to format the
+  # Domain::WorkItemsLimit structure for a dispatcher.
+  class WorkItemsLimit < Base
+    DEFAULT_DOMAIN_LIMIT = 6
+
+    # Initializes the formatter with essential configuration parameters.
+    #
+    # <b>limits</b> : expect a map with the wip limits by domain. Example: { "ops": 5 }
+    def initialize(config = {})
+      super(config)
+
+      @limits = config[:limits]
+    end
+
+    # Implements the logic for building a formatted payload with the given template for wip limits.
+    #
+    # <br>
+    # <b>Params:</b>
+    # * <tt>List<Domain::WorkItemsLimit></tt> work_items_list: List of mapped work items limits.
+    #
+    # <br>
+    # <b>raises</b> <tt>Formatter::Exceptions::InvalidData</tt> when invalid data is provided.
+    #
+    # <br>
+    # <b>returns</b> <tt>String</tt> payload, formatted payload suitable for a Dispatcher.
+    #
+
+    def format(work_items_list)
+      raise Formatter::Exceptions::InvalidData unless work_items_list.all? do |work_item|
+        work_item.is_a?(Domain::WorkItemsLimit)
+      end
+
+      exceeded_domains(work_items_list).reduce("") do |payload, work_items_limit|
+        built_template = build_template(Domain::WorkItemsLimit::ATTRIBUTES, work_items_limit)
+        payload + format_message_by_case(built_template.gsub("\n", ""), work_items_limit)
+      end
+    end
+
+    private
+
+    def format_message_by_case(template, work_items_limit)
+      total_items = work_items_limit.total
+      limit = domain_limit(work_items_limit.domain)
+
+      template + ", #{total_items} of #{limit}\n"
+    end
+
+    def exceeded_domains(work_items_list)
+      work_items_list.filter { |work_item| work_item.total > domain_limit(work_item.domain) }
+    end
+
+    def domain_limit(domain)
+      @limits[domain.to_sym] || DEFAULT_DOMAIN_LIMIT
+    end
+  end
+end