rails_attend 0.0.1

data/app/models/attend/attendance.rb

@@ -0,0 +1,5 @@
+module Attend
+  class Attendance < ApplicationRecord
+    include Model::Attendance
+  end
+end

data/app/models/attend/attendance_log.rb

@@ -0,0 +1,5 @@
+module Attend
+  class AttendanceLog < ApplicationRecord
+    include Model::AttendanceLog
+  end
+end

data/app/models/attend/attendance_setting.rb

@@ -0,0 +1,5 @@
+module Attend
+  class AttendanceSetting < ApplicationRecord
+    include Model::AttendanceSetting
+  end
+end

data/app/models/attend/attendance_stat.rb

@@ -0,0 +1,5 @@
+module Attend
+  class AttendanceStat < ApplicationRecord
+    include Model::AttendanceStat
+  end
+end

data/app/models/attend/ext/member.rb

@@ -0,0 +1,33 @@
+module Attend
+  module Ext::Member
+    extend ActiveSupport::Concern
+
+    included do
+      has_one :absence_stat, -> { where(year: Date.today.year) }
+      has_many :absences, class_name: 'Attend::Absence', dependent: :destroy
+      has_many :overtimes, class_name: 'Attend::Overtime', dependent: :destroy
+      has_many :attendances, class_name: 'Attend::Attendance', dependent: :destroy
+      has_many :attendance_logs, class_name: 'Attend::AttendanceLog', dependent: :nullify
+      has_many :attendance_stats, class_name: 'Attend::AttendanceStat', dependent: :destroy
+      has_many :attendance_settings, class_name: 'Attend::AttendanceSetting', dependent: :destroy
+
+      composed_of :absent, mapping: ['id', 'member_id']
+    end
+
+    def attendance_setting(date = Date.today)
+      _attendance_setting = self.attendance_settings.default_where('financial_month.begin_date-lte': date).first
+      _attendance_setting || self.attendance_settings.build(financial_month: FinancialMonth.current_month)
+    end
+
+    def on_time(date = Date.today)
+      hour, min = (self.attendance_setting(date).on_time).split(':')
+      date.in_time_zone(timezone).change(hour: hour, min: min)
+    end
+
+    def off_time(date = Date.today)
+      hour, min = (self.attendance_setting(date).off_time).split(':')
+      date.in_time_zone(timezone).change(hour: hour, min: min)
+    end
+
+  end
+end

data/app/models/attend/extra_day.rb

@@ -0,0 +1,5 @@
+module Attend
+  class ExtraDay < ApplicationRecord
+    include Model::ExtraDay
+  end
+end

data/app/models/attend/financial_month.rb

@@ -0,0 +1,5 @@
+module Attend
+  class FinancialMonth < ApplicationRecord
+    include Model::FinancialMonth
+  end
+end

data/app/models/attend/model/absence/business_trip.rb

@@ -0,0 +1,10 @@
+module Attend
+  module Model::Absence::BusinessTrip
+    extend ActiveSupport::Concern
+
+    included do
+      validates :note, presence: true
+    end
+
+  end
+end

data/app/models/attend/model/absence/compensatory_leave.rb

@@ -0,0 +1,5 @@
+module Attend
+  module Model::Absence::CompensatoryLeave
+
+  end
+end

data/app/models/attend/model/absence/personal_leave.rb

@@ -0,0 +1,5 @@
+module Attend
+  module Model::Absence::PersonalLeave
+
+  end
+end

data/app/models/attend/model/absence/welfare_leave/annual_leave.rb

@@ -0,0 +1,16 @@
+module Attend
+	module Model::Absence::WelfareLeave::AnnualLeave #年假
+		extend ActiveSupport::Concern
+
+		included do
+			validate :validate_left_hours, if: -> { start_at_changed? || finish_at_changed? }
+		end
+
+		def validate_left_hours
+			if self.hours > self.absent.left_hours.to_f
+				self.errors.add :base, 'You do not have enough annual hours!'
+			end
+		end
+
+	end
+end

data/app/models/attend/model/absence/welfare_leave/vacation_leave.rb

@@ -0,0 +1,16 @@
+module Attend
+	module Model::Absence::WelfareLeave::VacationLeave
+		extend ActiveSupport::Concern
+
+		included do
+			validate :validate_left_hours, if: -> { start_at_changed? || finish_at_changed? }
+		end
+
+		def validate_left_hours
+			if self.hours > self.absent.left_hours.to_f
+				self.errors.add :base, 'You do not have enough annual hours!'
+			end
+		end
+
+	end
+end

data/app/models/attend/model/absence/welfare_leave.rb

@@ -0,0 +1,5 @@
+module Attend
+  module Model::Absence::WelfareLeave
+
+  end
+end

data/app/models/attend/model/absence.rb

@@ -0,0 +1,208 @@
+module Attend
+  module Model::Absence
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :type, :string
+      attribute :state, :string, default: 'init'
+      attribute :hours, :float, default: 0
+      attribute :kind, :string
+      attribute :start_at, :datetime
+      attribute :finish_at, :datetime
+      attribute :note, :string, limit: 2048
+      attribute :comment, :string, limit: 2048
+      attribute :redeeming, :boolean
+      attribute :redeeming_days, :string, array: true
+      attribute :processed, :boolean, default: false
+      attribute :divided, :boolean, default: false
+
+      belongs_to :member
+      belongs_to :merged, class_name: self.name, optional: true
+      has_many :divideds, class_name: self.name, foreign_key: 'merged_id'
+
+      composed_of :absent, mapping: [
+        ['member_id', 'member_id'],
+        ['type', 'type']
+      ]
+
+      enum state: {
+        init: 'init',
+        approved: 'approved',
+        denied: 'denied'
+      }
+
+      scope :current_range, -> (begin_date, finish_date) {
+        default_where('start_at-gte': begin_date, 'finish_at-lte': finish_date, state: ['init', 'approved'])
+      }
+      scope :current_range_stat, -> (begin_date, finish_date) {
+        current_range(begin_date, finish_date).group(:type).sum(:hours)
+      }
+      scope :current_range_events, -> (begin_date, finish_date, department_ids) {
+        current_range(begin_date, finish_date).default_where('member.department_id': department_ids).map do |i|
+          {
+            title: i.member.name,
+            start: i.start_at,
+            end: i.finish_at,
+            url: i.url_helpers.oa_absence_path(i.id)
+          }
+        end.as_json
+      }
+
+      validate :validate_same_month, if: -> { start_at_changed? || finish_at_changed? }
+      validates :start_at, presence: true
+      validates :finish_at, presence: true
+
+      before_save :compute_hours
+      after_create_commit :send_notification
+
+      delegate :name, to: :member, prefix: true
+      acts_as_notify(
+        :default,
+        only: [:hours, :start_at, :finish_at, :note],
+        methods: [:member_name, :type_i18n, :state_i18n]
+      )
+      acts_as_notify(
+        :request,
+        only: [:hours, :start_at, :finish_at, :note],
+        methods: [:member_name, :type_i18n, :state_i18n],
+        cc_emails: [
+          -> (o){ o.member.office&.absence_email },
+          -> (o){ o.member.email },
+          -> (o){ o.cc_emails }
+        ]
+      )
+    end
+
+    def do_trigger(params = {})
+      self.trigger_to(params.slice(:state))
+
+      if self.approved?
+        sync_attendance
+      end
+
+      self.class.transaction do
+        self.save!
+        to_notification(
+          member: member,
+          link: url_helpers.oa_absences_url(id: self.id),
+          verbose: true
+        )
+      end
+    end
+
+    def send_notification
+      to_notification(
+        member: member.parent,
+        link: url_helpers.my_admin_absences_url(id: self.id),
+        code: :request,
+        verbose: true
+      )
+    end
+
+    def compute_hours
+      _hours = 0
+
+      if workdays.size > 2
+        _hours += (workdays.size - 2) * 8
+      end
+
+      if workdays.size > 1
+        _seconds_start = TimeHelper.interval(start_time, off_time)
+        _hours += _seconds_start.div(1800) / 2.0
+
+        _seconds_finish = TimeHelper.interval(on_time, finish_time)
+        _hours += (_seconds_finish).div(1800) / 2.0
+      else
+        _start_at = start_time > on_time ? start_time : on_time
+        _finish_at = finish_time < off_time ? finish_time : off_time
+        _seconds = TimeHelper.interval(_start_at, _finish_at)
+        _hours = _seconds.div(1800) / 2.0
+      end
+
+      self.hours = _hours
+      self.processed = true
+    end
+
+    def compute_hours!
+      self.compute_hours
+      self.save
+    end
+
+    def workdays
+      @workdays ||= (start_time.to_date..finish_time.to_date).reject { |date| financial_month.rest_day?(date) }
+    end
+
+    def on_time
+      return @on_time if @on_time
+
+      if workdays.size > 1
+        @on_time = self.member.on_time.change year: finish_at.year, month: finish_at.month, day: finish_at.day
+      else
+        @on_time = self.member.on_time.change year: start_at.year, month: start_at.month, day: start_at.day
+      end
+    end
+
+    # todo repeat with attendance
+    def start_time
+      start_at.in_time_zone(member.timezone)
+    end
+
+    # todo repeat with attendance
+    def finish_time
+      finish_at.in_time_zone(member.timezone)
+    end
+
+    def off_time
+      return @off_time if @off_time
+
+      if workdays.size > 1
+        @off_time = self.member.off_time.change year: start_at.year, month: start_at.month, day: start_at.day
+      else
+        @off_time = self.member.off_time.change year: finish_at.year, month: finish_at.month, day: finish_at.day
+      end
+    end
+
+    def sync_attendance
+      self.workdays.each_with_index do |workday, index|
+        att = self.member.attendances.find_or_initialize_by('attend_on': workday)
+
+        if index == 0 && self.start_at <= self.on_time
+          att.late_absence_id = self.id
+        elsif index == 0 && self.finish_at >= self.off_time
+          att.leave_absence_id = self.id
+        else
+          att.interval_absence_id = self.id
+        end
+
+        att.save
+      end
+    end
+
+    def financial_months
+      FinancialMonth.default_where('begin_date-lte': self.start_at.to_date, 'end_date-gte': self.finish_at.to_date)
+    end
+
+    def financial_month
+      @financial_month ||= financial_months.take
+    end
+
+    def validate_same_month
+      count = financial_months.count
+      if count > 1
+        self.errors.add :base, 'You can not request crossing financial month, please make more than one request'
+      end
+      if self.finish_at < self.start_at
+        self.errors.add :base, 'Start time can not be later than end'
+      end
+    end
+
+    class_methods do
+      def available_rest_days
+        # todo improve performance, use bsearch
+        _rest_days = FinancialMonth.available_rest_days.select { |d| d >= Date.today }
+        Array(_rest_days).map { |d| [d.to_s, d.to_s] }
+      end
+    end
+
+  end
+end

data/app/models/attend/model/absence_stat.rb

@@ -0,0 +1,17 @@
+module Attend
+  module Model::AbsenceStat
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :year, :string
+      attribute :annual_days, :float
+      attribute :annual_add, :float
+      attribute :left_annual_days, :float
+      attribute :vacation_days, :float
+      attribute :details, :string, limit: 1024
+
+      belongs_to :member
+    end
+
+  end
+end

data/app/models/attend/model/attendance.rb

@@ -0,0 +1,314 @@
+module Attend
+  module Model::Attendance
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :late_minutes, :integer
+      attribute :leave_minutes, :integer
+      attribute :overtime_hours, :float
+      attribute :attend_hours, :float
+      attribute :interval_hours, :float
+      attribute :total_hours, :float
+      attribute :attend_on, :date
+      attribute :start_at, :datetime
+      attribute :finish_at, :datetime
+      attribute :interval_start_at, :datetime
+      attribute :interval_finish_at, :datetime
+      attribute :kind, :string
+      attribute :absence_minutes, :integer
+      attribute :absence_redeeming, :boolean
+      attribute :lost_logs, :string, array: true
+      attribute :workday, :boolean, default: true
+      attribute :processed, :boolean, default: false
+
+      belongs_to :member
+      belongs_to :interval_absence, class_name: 'Absence', optional: true
+      belongs_to :late_absence, class_name: 'Absence', optional: true
+      belongs_to :leave_absence, class_name: 'Absence', optional: true
+      has_many :attendance_logs, dependent: :nullify
+
+      enum kind: {
+        belated: 'belated',
+        asked_leave: 'asked_leave',
+        no_meal: 'no_meal',
+        allowance: 'allowance'
+      }
+
+      validates :attend_on, uniqueness: { scope: :member_id }
+      before_save :sync_workday, if: -> { attend_on_changed? }
+    end
+
+    def compute_time_type(record_at)
+      arr = [start_at, interval_start_at, interval_finish_at, finish_at, record_at].compact.uniq
+      arr.sort!
+
+      if arr.length < 4
+        arr.mjust! 4, nil
+      end
+
+      if arr.length == 5
+        if arr[1] < self.on_time
+          arr.delete_at(1)
+        elsif arr[-2] > self.off_time
+          arr.delete_at(-2)
+        else
+          arr.delete_at(2)
+        end
+      end
+
+      logger.debug "-----> results: #{arr.map(&->(o){ o.to_s }).inspect}"
+
+      result = arr.find_index { |x| x == record_at }
+
+      self.start_at = arr[0]
+      self.interval_start_at = arr[1] if arr[1] && arr[1] > self.on_time
+      self.interval_finish_at = arr[-2] if arr[-2] && arr[-2] < self.off_time
+      self.finish_at = arr[-1]
+
+      if result
+        ['start_at', 'interval_start_at', 'interval_finish_at', 'finish_at'].fetch(result)
+      else
+        nil
+      end
+    end
+
+    def compute_summary
+      if self.finish_at && self.start_at
+        self.total_hours = (self.finish_at - self.start_at).div(1800) / 2.0
+      else
+        return
+      end
+
+      late_summary
+      leave_summary
+      self.absence_minutes = self.late_minutes.to_i + self.leave_minutes.to_i
+
+      interval_summary
+      total_leave = self.interval_hours.to_f + (self.absence_minutes / 30.0).ceil / 2.0
+      self.attend_hours = 8 - total_leave
+
+      if self.attend_hours < 8 && self.attend_hours > 4
+        self.kind = 'belated'
+      elsif self.attend_hours < 4
+        self.kind = 'no_meal'
+      else
+        self.kind = 'allowance'
+      end
+
+      self.overtime_hours = morning_over + evening_over
+      self.processed = true
+      self.changes
+    end
+
+    def compute_summary!
+      self.compute_summary
+      self.save
+    end
+
+    def start_time
+      @start_time ||= start_at.in_time_zone(member.timezone)
+    end
+
+    def finish_time
+      @finish_time ||= finish_at.in_time_zone(member.timezone)
+    end
+
+    def interval_start_time
+      @interval_start_time ||= interval_start_at.in_time_zone(member.timezone)
+    end
+
+    def interval_finish_time
+      @interval_finish_time ||= interval_finish_at.in_time_zone(member.timezone)
+    end
+
+    def off_time
+      return @off_time if @off_time
+      if night_shift
+        @off_time = self.attend_on.to_datetime.in_time_zone(member.timezone).change hour: 21
+      else
+        @off_time = self.member.off_time(self.attend_on)
+      end
+    end
+
+    def on_time
+      return @on_time if @on_time
+      if night_shift
+        @on_time = self.attend_on.to_datetime.in_time_zone(member.timezone).change hour: 13
+      else
+        @on_time = self.member.on_time(self.attend_on)
+      end
+    end
+
+    def night_shift
+      return false unless member.department&.night_shift
+
+      self.start_time.hour <= 13 && self.start_time.hour >= 11 && self.finish_time.hour >= 21
+    end
+
+    def lunch_time
+      return @lunch_time if @lunch_time
+      start = self.member.lunch_time[0].change year: attend_on.year, month: attend_on.month, day: attend_on.day
+      finish = self.member.lunch_time[1].change year: attend_on.year, month: attend_on.month, day: attend_on.day
+      @lunch_time = [start, finish]
+    end
+
+    def interval_time
+      return @interval_time if @interval_time
+      return [] unless interval_start_time && interval_finish_time
+
+      if interval_start_time > lunch_time[0] && interval_start_time < lunch_time[1]
+        start = lunch_time[1]
+      else
+        start = interval_start_time
+      end
+
+      if interval_finish_time > lunch_time[0] && interval_finish_time < lunch_time[1] && interval_finish_time > start
+        finish = lunch_time[0]
+      elsif interval_finish_time > lunch_time[0] && interval_finish_time < lunch_time[1] && interval_finish_time <= start
+        finish = lunch_time[1]
+      else
+        finish = interval_finish_time
+      end
+
+      @interval_time = [start, finish]
+    end
+
+    def morning_time
+      @morning_time ||= on_time - 30.minutes
+    end
+
+    def evening_time
+      @evening_time ||= off_time + 90.minutes
+    end
+
+    def evening_over
+      return 0 if self.finish_at.blank? || leave_early?
+      if self.finish_time < evening_time
+        result = self.finish_time.to_i - off_time.to_i
+      else
+        result = evening_time.to_i - off_time.to_i
+      end
+
+      result.div(1800) / 2.0
+    end
+
+    def morning_over
+      return 0 if self.start_at.blank? || late?
+      if self.start_time < morning_time
+        result = on_time.to_i - morning_time.to_i
+      else
+        result = on_time.to_i - self.start_time.to_i
+      end
+
+      result.div(1800) / 2.0
+    end
+
+    def late?
+      self.start_at && self.start_time > self.on_time
+    end
+
+    def late_summary
+      return unless self.start_time
+      unless late?
+        self.late_absence_id = nil
+        return if self.late_minutes.blank?
+      end
+
+      if self.start_time > self.on_time
+        self.late_minutes = ((self.start_time.to_i - on_time.to_i) / 60.0).floor
+        _late = Absence.default_where(member_id: self.member_id, 'start_at-lte': start_time, 'finish_at-gte': start_time, 'finish_at-lte': off_time).take
+        if _late
+          self.late_absence_id = _late.id
+        else
+          self.late_absence_id = nil
+        end
+      else
+        self.late_minutes = nil
+      end
+    end
+
+    def leave_early?
+      self.finish_at && self.finish_time < self.off_time
+    end
+
+    def leave_summary
+      return unless self.finish_at
+      unless leave_early?
+        self.leave_absence_id = nil
+        return if self.leave_minutes.blank?
+      end
+
+      if self.finish_time < self.off_time
+        self.leave_minutes = ((off_time.to_i - self.finish_time.to_i) / 60.0).floor
+        _leave = Absence.default_where(member_id: self.member_id, 'start_at-gte': finish_time, 'finish_at-lte': off_time).take
+        if _leave
+          self.leave_absence_id = _leave.id
+        else
+          self.leave_absence_id = nil
+        end
+      else
+        self.leave_minutes = nil
+      end
+    end
+
+    def interval_leave?
+      return false unless interval_start_at && interval_finish_at
+      !(self.interval_start_time > self.lunch_time[0] && self.interval_finish_time < self.lunch_time[1])
+    end
+
+    def interval_summary
+      return unless interval_leave?
+
+      _interval = Absence.default_where(member_id: self.member_id, 'start_at-lte': interval_start_time, 'finish_at-gte': interval_finish_time).take
+      if _interval
+        self.interval_absence_id = _interval.id
+      else
+        self.interval_absence_id = nil
+      end
+
+      _interval_seconds = TimeHelper.interval(self.interval_time[0], self.interval_time[1], interval_start: '12:30')
+      interval = (_interval_seconds / 1800.0).ceil / 2.0
+      self.interval_hours = interval
+    end
+
+    def financial_month
+      @financial_month ||= FinancialMonth.current_month(self.attend_on)
+    end
+
+    def sync_workday
+      if self.rest_day?
+        self.workday = false
+      end
+    end
+
+    def work_day?
+      financial_month.work_day?(self.attend_on)
+    end
+
+    def rest_day?
+      financial_month.rest_day?(self.attend_on)
+    end
+
+    class_methods do
+      def compute_summary!
+        self.where(processed: false).each do |at|
+          at.compute_summary!
+        end
+      end
+
+      def notify_completion
+        normal_ids = self.distinct(:member_id).where(finish_time: nil).where.not(start_at: nil).pluck(:member_id)
+        normal_ids.each do |member_id|
+          AttendanceMailer.normal_completion(member_id).deliver_later
+        end
+
+        interval_ids = self.distinct(:member_id).where(interval_finish_at: nil).where.not(interval_start_at: nil).pluck(:member_id)
+        interval_ids.each do |member_id|
+          AttendanceMailer.interval_completion(member_id).deliver_later
+        end
+        [normal_ids, interval_ids]
+      end
+    end
+
+  end
+end