pd1_tools 0.43.0

data/lib/avmtrf1/forponto/user/balance.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Forponto
+    class User
+      class Balance
+        include ::EacRubyUtils::SimpleCache
+
+        attr_reader :user
+
+        def initialize(user)
+          @user = user
+          build_balances
+        end
+
+        def months_balances_uncached
+          sorted_months.map { |m| MyBalance.new(m) }
+        end
+
+        def sorted_months_uncached
+          r = []
+          current = head_month
+          while current.present?
+            r << current
+            current = current.parent_month
+          end
+          r.reverse
+        end
+
+        def head_month
+          today = ::Date.today # rubocop:disable Rails/Date
+          date = ::Date.civil(today.year, today.month, 1)
+          user.month(date.year, date.month)
+        end
+
+        def debito_left
+          months_balances.inject(0) { |a, e| a + e.debito.left }
+        end
+
+        def credito_left
+          months_balances.inject(0) { |a, e| a + e.credito.left }
+        end
+
+        def saldo_left
+          credito_left - debito_left
+        end
+
+        private
+
+        def build_balances
+          previous = []
+          months_balances.each do |current|
+            current.consume(previous)
+            previous << current
+            if previous.count > 3
+              removed = previous.shift
+              removed.mark_lost
+            end
+          end
+        end
+
+        class MyBalance
+          attr_accessor :debito, :credito, :month, :lost
+
+          def initialize(month)
+            @month = month
+            @debito = AttrConsumer.new(self, false, month.debito)
+            @credito = AttrConsumer.new(self, true, month.credito)
+            @lost = false
+          end
+
+          def after_trigger
+            credito.after_trigger - debito.after_trigger
+          end
+
+          def after_trigger_acum
+            credito.after_trigger_acum - debito.after_trigger_acum
+          end
+
+          def mark_lost
+            @lost = true
+          end
+
+          delegate :to_s, to: :month
+
+          def consume(previous)
+            debito.consume_from_months(previous)
+            credito.consume_from_months(previous)
+          end
+
+          class AttrConsumer
+            attr_reader :owner_month, :initial_value, :left, :unconsumed, :withdrawals, :requests,
+                        :after_trigger, :after_trigger_acum
+
+            def initialize(owner_month, credito, initial_value)
+              @owner_month = owner_month
+              @credito = credito
+              @left = initial_value
+              @initial_value = initial_value
+              @withdrawals = []
+              @requests = []
+              @after_trigger = nil
+            end
+
+            def to_s
+              "[#{owner_month}|#{attr}]"
+            end
+
+            def consume_from_months(months)
+              (months + [owner_month]).each do |month|
+                break unless left.positive?
+
+                consume_from_month(month)
+              end
+              @after_trigger = left
+              @after_trigger_acum = months.inject(0) { |a, e| a + e.send(attr).left } + left
+            end
+
+            def withdrawal(month, value)
+              month.assert_argument(MyBalance, :month)
+              raise "Value is not positive: #{value} (Month: #{month})" unless value.positive?
+
+              self.left -= value
+              raise "Left less than zero: #{left} (Value: #{value})" if left.negative?
+
+              @withdrawals << OpenStruct.new(month: month, value: value) # rubocop:disable Style/OpenStructUse
+            end
+
+            private
+
+            attr_writer :left, :unconsumed
+
+            def consume_from_month(month)
+              month_attr = month.send(reverse_attr)
+              return unless month_attr.left.positive?
+
+              value = [left, month_attr.left].min
+              self.left -= value
+              month_attr.withdrawal(owner_month, value)
+              @requests << OpenStruct.new(month: month, value: value) # rubocop:disable Style/OpenStructUse
+            end
+
+            def attr
+              @credito ? :credito : :debito
+            end
+
+            def reverse_attr
+              @credito ? :debito : :credito
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/forponto/user/day_registers.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/core_ext'
+
+module Avmtrf1
+  module Forponto
+    class User
+      class DayRegisters
+        enable_simple_cache
+        common_constructor :user
+
+        def date
+          fresh_data
+          @date
+        end
+
+        def times
+          fresh_data.map { |r| r[:hora] }
+        end
+
+        private
+
+        def fresh_data_uncached
+          r = ::Avmtrf1::Forponto::Session.new(user.url, user.matricula, user.codigo)
+                .day_registers_data
+          @date = ::Date.today # rubocop:disable Rails/Date
+          r
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/forponto/user/month.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require 'active_support/json'
+require 'eac_ruby_utils/core_ext'
+require 'eac_ruby_utils/yaml'
+require 'recursive-open-struct'
+require 'avmtrf1/forponto/parsers/espelho'
+require 'avmtrf1/forponto/session'
+
+module Avmtrf1
+  module Forponto
+    class User
+      class Month
+        enable_simple_cache
+
+        DEBITO_CODE = 66
+        CREDITO_CODE = 72
+
+        attr_reader :user, :year, :month
+
+        def initialize(user, year, month)
+          @user = user
+          @year = year
+          @month = month
+        end
+
+        def data_uncached
+          if recache?
+            r = fresh_data
+            data_cache.write(r.to_yaml)
+            r
+          else
+            cached_data
+          end
+        end
+
+        def to_s
+          month.to_s.rjust(2, '0') + '/' + year.to_s # rubocop:disable Style/StringConcatenation
+        end
+
+        def empty?
+          os_data.summaries.empty?
+        end
+
+        def debito_acumulado; end
+
+        def debito
+          summary_minutes(DEBITO_CODE)
+        end
+
+        def debito_acum
+          debito + (parent_month ? parent_month.debito_acum : 0)
+        end
+
+        def credito_acum
+          credito + (parent_month ? parent_month.credito_acum : 0)
+        end
+
+        def saldo
+          credito - debito
+        end
+
+        def saldo_acum
+          credito_acum - debito_acum
+        end
+
+        def credito
+          summary_minutes(CREDITO_CODE)
+        end
+
+        private
+
+        def summary_minutes(code)
+          summary = os_data.summaries.find { |s| s.code == code }
+          summary ? summary.minutes : 0
+        end
+
+        def parent_month_uncached
+          date = Date.civil(year, month, 1) - 1.month
+          r = user.month(date.year, date.month)
+          r.empty? ? nil : r
+        end
+
+        def os_data_uncached
+          ::RecursiveOpenStruct.new(data, recurse_over_arrays: true)
+        end
+
+        def recache?
+          !data_cache.stored? || yesterday_uncached?
+        end
+
+        def yesterday_uncached?
+          last_cached_day < end_date && last_cached_day < (::Date.today - 1.day) # rubocop:disable Rails/Date
+        end
+
+        def last_cached_day_uncached
+          cached_data.fetch('days').map { |day| day.fetch('date') }.max
+        end
+
+        def data_cache_uncached
+          ::Avmtrf1.fs_cache.child('forponto', user.matricula, year.to_s, month.to_s.rjust(2, '0'))
+        end
+
+        def date(day)
+          ::Date.civil(year, month, day)
+        end
+
+        def start_date_uncached
+          date(1)
+        end
+
+        def end_date_uncached
+          date(-1)
+        end
+
+        def cached_data
+          raise 'There is no data cached' unless data_cache.stored?
+
+          ::EacRubyUtils::Yaml.load(data_cache.read)
+        end
+
+        def fresh_data
+          session = new_session
+          begin
+            session.interval_data(start_date, end_date).merge(fetch_data)
+          ensure
+            session.sub.close
+          end
+        end
+
+        def fetch_data
+          { year: year, month: month, url: user.url, matricula: user.matricula }
+        end
+
+        def new_session
+          ::Avmtrf1::Forponto::Session.new(user.url, user.matricula, user.codigo)
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/forponto/user.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/require_sub'
+EacRubyUtils.require_sub(__FILE__)
+
+module Avmtrf1
+  module Forponto
+    class User
+      attr_reader :url, :matricula, :codigo
+
+      def initialize(url, matricula, codigo)
+        @url = url
+        @matricula = matricula
+        @codigo = codigo
+      end
+
+      def month(year, month)
+        ::Avmtrf1::Forponto::User::Month.new(self, year, month)
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/cached_repository.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'avm/git/launcher/base'
+
+module Avmtrf1
+  module Git
+    class CachedRepository < ::Avm::Git::Launcher::Base
+      attr_reader :url
+
+      def initialize(url)
+        @url = url
+        super(local_path)
+        init
+        assert_remote_url('origin', url)
+        system!('fetch', 'origin', '-pPt')
+      end
+
+      private
+
+      def local_path
+        r = ::File.join(ENV.fetch('HOME', nil), '.cache', 'git_cached_repositories', url.parameterize) # rubocop:disable Style/EnvHome, Layout/LineLength
+        ::FileUtils.mkdir_p(::File.dirname(r))
+        r
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/gitlab.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'avmtrf1/tools/core_ext'
+
+module Avmtrf1
+  module Git
+    module Gitlab
+      require_sub __FILE__
+    end
+  end
+end

data/lib/avmtrf1/git/issue_on_repository.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'eac_ruby_utils/patches/module/speaker'
+require 'eac_ruby_utils/simple_cache'
+require 'avmtrf1/result'
+
+module Avmtrf1
+  module Git
+    class IssueOnRepository
+      enable_speaker
+      include ::EacRubyUtils::SimpleCache
+
+      CHECKS = %w[no_branch_nor_tag branch_and_tag issue_not_found issue_closed_git_open
+                  issue_open_git_closed issue_open_git_open issue_closed_git_closed].freeze
+
+      def initialize(issue_id, refs)
+        @issue_id = issue_id
+        @refs = refs
+      end
+
+      def check
+        infov issue_id, "#{result.label} [#{issue ? issue.status_name : '-'}]"
+      end
+
+      private
+
+      attr_reader :issue_id, :refs
+
+      def result_uncached
+        CHECKS.each do |check|
+          result = send("#{check}_check")
+          return result if result
+        end
+        ::Avmtrf1::Result.error('condição não encontrada')
+      end
+
+      def no_branch_nor_tag_check
+        return nil unless branch_ref.blank? && tag_ref.blank?
+
+        ::Avmtrf1::Result.error("nem branch nem tag encontrado com o nome \"#{issue_id}\"")
+      end
+
+      def branch_and_tag_check
+        return nil unless branch_ref.present? && tag_ref.present?
+
+        ::Avmtrf1::Result.error("há uma branch e uma tag com o nome \"#{issue_id}\"")
+      end
+
+      def issue_not_found_check
+        return nil if issue.present?
+
+        if tag_ref.present?
+          ::Avmtrf1::Result.neutral('demanda não encontrada e Git fechado')
+        else
+          ::Avmtrf1::Result.neutral('demanda não encontrada e Git aberto')
+        end
+      end
+
+      def issue_closed_git_open_check
+        return nil unless issue.closed? && !git_closed?
+
+        ::Avmtrf1::Result.error('demanda fechada e Git aberto')
+      end
+
+      def issue_open_git_closed_check
+        return nil unless !issue.closed? && git_closed?
+
+        ::Avmtrf1::Result.error('demanda aberta e Git fechado')
+      end
+
+      def issue_open_git_open_check
+        return nil unless !issue.closed? && !git_closed?
+
+        ::Avmtrf1::Result.success('demanda aberta e Git aberto')
+      end
+
+      def issue_closed_git_closed_check
+        return nil unless issue.closed? && git_closed?
+
+        ::Avmtrf1::Result.success('demanda fechada e Git fechado')
+      end
+
+      def git_closed?
+        tag_ref.present?
+      end
+
+      def branch_ref_uncached
+        refs.find { |ref| ref.type == 'head' }
+      end
+
+      def tag_ref_uncached
+        refs.find { |ref| ref.type == 'tag' }
+      end
+
+      def issue_uncached
+        ::Avmtrf1::IssueFactory.find(issue_id)
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/_utils.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class << self
+        def bytes_size(size)
+          return 'NONE' if size.blank?
+
+          b = "#{size} B"
+          "#{::Filesize.from(b).pretty} (#{b})"
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/lfs_commit/cache.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class LfsCommit
+        module Cache
+          def fs_cache
+            @fs_cache ||= source_commit.fs_cache.child(
+              lfs_file_min_size.presence || 'nil'
+            )
+          end
+
+          %w[sha1 files_size push_pack_error].each do |attr|
+            define_method("#{attr}_cache_uncached") { fs_cache.child(attr) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/lfs_commit/checkout_previous_revision.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class LfsCommit
+        module CheckoutPreviousRevision
+          private
+
+          def checkout_base_uncached
+            if previous_revision.blank?
+              checkout_orphan
+            else
+              checkout_previous_revision
+            end
+          end
+
+          def checkout_orphan
+            infom message('Checkout orphan')
+            git.execute!('reset', '--hard')
+            git.execute!('clean', '-df')
+            git.execute!('checkout', source_commit.sha1)
+          end
+
+          def checkout_previous_revision
+            infom message("Checkout previous revision #{previous_revision}")
+            git.execute!('reset', '--hard')
+            git.execute!('clean', '-df')
+            git.execute!('checkout', previous_revision)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/lfs_commit/commit_changes.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class LfsCommit
+        module CommitChanges
+          # @return [Avm::Git::Commit]
+          def commit
+            commit_changes
+            @commit
+          end
+
+          private
+
+          def commit_changes_uncached
+            if sha1_cache.read.present?
+              @commit = ::Avm::Git::Commit.new(git, sha1_cache.read)
+              return
+            end
+            track_large_files
+            add_files
+            commit_amend
+            store_commit
+          end
+
+          def add_files
+            infom '    * Adding files'
+            git.system!('add', '.')
+          end
+
+          def commit_amend
+            infom message('Commiting')
+            git.command('commit', '--amend', '--allow-empty', '--allow-empty-message')
+              .envvar('GIT_EDITOR', true).execute!
+          end
+
+          def store_commit
+            @commit = ::Avm::Git::Commit.new(git, git.rev_parse('HEAD'))
+            infov message('Commited (SHA1)'), @commit.sha1
+            sha1_cache.write(@commit.sha1)
+            files_size_cache.write(@commit.files_size)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/avmtrf1/git/push_large/lfs_commit/helpers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Avmtrf1
+  module Git
+    class PushLarge
+      class LfsCommit
+        module Helpers
+          private
+
+          def message(suffix, padding = 0)
+            "#{'  ' * (padding + 2)}* #{suffix}"
+          end
+
+          def git
+            source_commit.git
+          end
+
+          def push_large
+            source_commit.push_large
+          end
+
+          def previous_revision
+            push_large.last_pushed_revision
+          end
+        end
+      end
+    end
+  end
+end