rails_attend 0.0.1

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

@@ -0,0 +1,165 @@
+module Attend
+  module Model::AttendanceLog
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :source, :string, default: 'machine'
+      attribute :state, :string, default: 'init'
+      attribute :name, :string
+      attribute :record_at, :datetime
+      attribute :processed, :boolean, default: false
+      attribute :kind, :string
+      attribute :note, :string
+      attribute :record_at_str, :string
+      attribute :number, :string
+
+      belongs_to :unsure_member, class_name: 'Member', foreign_key: 'number', primary_key: 'attendance_number', optional: true
+      belongs_to :member, optional: true
+      belongs_to :attendance, optional: true
+
+      validates :record_at, presence: true, unless: -> { self.source == 'machine' }
+      validates :record_at_str, presence: true, if: -> { self.source == 'machine' }
+
+      scope :pending, -> { where(state: 'init', processed: false) }
+
+      enum state: {
+        init: 'init',
+        valid: 'valid',
+        invalid: 'invalid'
+      }, _prefix: true
+
+      enum kind: {
+        start_at: 'start_at',
+        finish_at: 'finish_at',
+        interval_start_at: 'interval_start_at',
+        interval_finish_at: 'interval_finish_at'
+      }
+
+      enum source: {
+        machine: 'machine',
+        myself: 'myself',
+        admin: 'admin'
+      }
+
+      delegate :name, to: :member, prefix: true
+      acts_as_notify :default,
+                     only: [:record_at, :note],
+                     methods: [:member_name, :state_i18n]
+      acts_as_notify :request,
+                     only: [:record_at, :note],
+                     methods: [:member_name]
+
+      after_initialize if: :new_record? do
+        self.state ||= 'init'
+      end
+      before_save :sync_member_id, if: -> { number_changed? }
+    end
+
+    def sync_member_id
+      self.member_id = self.unsure_member&.id
+      if self.member
+        self.record_at = self.record_at_str.in_time_zone(member.timezone)
+      end
+    end
+
+    def do_trigger(params = {})
+      self.trigger_to(params.slice(:state))
+
+      self.class.transaction do
+        self.save!
+        to_notification(
+          member: member,
+          link: url_helpers.oa_attendance_logs_url(id: self.id),
+          verbose: true,
+        )
+      end
+    end
+
+    def send_notification
+      to_notification(
+        member: member.parent,
+        cc_emails: [
+          self.member.office&.absence_email
+        ],
+        link: url_helpers.my_admin_attendance_logs_url(id: self.id),
+        code: :request,
+        verbose: true,
+        )
+    end
+
+    def editable?
+      self.state_init? && self.myself?
+    end
+
+    def record_at_begin
+      record_at.at_beginning_of_day
+    end
+
+    def record_at_end
+      record_at.at_end_of_day
+    end
+
+    def compute
+      analyze
+      self.attendance.compute_summary!
+    end
+
+    def analyze
+      return unless self.member
+      att = self.member.attendances.find_or_initialize_by('attend_on': self.record_at)
+      _kind = att.compute_time_type self.record_at
+
+      self.kind = _kind
+      self.processed = true
+      self.state = 'valid'
+
+      self.attendance = att
+
+      self.class.transaction do
+        self.redress_same_logs
+        att.save!
+        self.save!
+      end
+    end
+
+    def redress_same_logs
+      return AttendanceLog.none unless self.attendance
+      logs = AttendanceLog.where.not(id: self.id).where(member_id: self.member_id, attendance_id: self.attendance_id)
+      times = [attendance.start_at, attendance.interval_start_at, attendance.interval_finish_at, attendance.finish_at]
+      kinds = ['start_at', 'interval_start_at', 'interval_finish_at', 'finish_at']
+
+      logs.each do |log|
+        index = times.find_index { |x| x == log.record_at }
+        if index
+          _kind = kinds[index]
+        else
+          _kind = nil
+        end
+        log.kind = _kind
+        log.save!
+      end
+    end
+
+    class_methods do
+      def analyze
+        AttendanceLog.where(processed: false).each do |al|
+          al.analyze
+        end
+      end
+
+      def prepare
+        Attendance.where(member_id: nil).each do |i|
+          i.sync_member_id
+          i.save
+        end
+      end
+
+      def self.analyze_number
+        Member.where(enabled: true, attendance_number: [nil, '']).each do |member|
+          num = AttendanceLog.find_by(source: 'machine', name: member.profile&.real_name)&.number
+          member.update(attendance_number: num)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Attend
+  module Model::AttendanceSetting
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :effect_on, :date
+      attribute :expire_on, :date
+      attribute :on_time, :string, default: '08:30'
+      attribute :off_time, :string
+      attribute :note, :string
+
+      belongs_to :member
+
+      enum state: {
+        init: 'init',
+        approved: 'approved',
+        denied: 'denied'
+      }, _default: 'init'
+
+      after_initialize do
+        self.compute_off_time
+      end
+      before_save :compute_off_time, if: -> { on_time_changed? }
+
+      acts_as_notify
+    end
+
+    def do_trigger(params = {})
+      self.trigger_to(params.slice(:state))
+
+      self.class.transaction do
+        self.save!
+        member.save!
+        to_notification(
+          member: member,
+          title: "Your Attendance Setting has been #{self.state_i18n}",
+          body: "Your Attendance Setting has been #{self.state_i18n}",
+          link: url_helpers.oa_attendance_settings_url
+        )
+      end
+    end
+
+    def compute_off_time
+      if ['08', '8'].include? on_time.to_s.split(':').first
+        self.off_time = '17:30'
+      else
+        self.off_time = '18:00'
+      end
+    end
+
+    class_methods do
+      def time_options
+        [
+          ['09:00', '09:00'],
+          ['08:30', '08:30']
+        ]
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,104 @@
+module Attend
+  module Model::AttendanceStat
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :costed_absence, :json, default: {}
+      attribute :redeeming_absence, :json, default: {}
+      attribute :free_absence, :json, default: {}
+      attribute :allowance_days, :integer
+      attribute :late_days, :integer
+      attribute :absence_redeeming_hours, :float
+      attribute :costed_absence, :string, limit: 1024
+      attribute :cost_absence_hours, :float
+      attribute :free_absence, :string, limit: 1024
+      attribute :redeeming_absence, :string, limit: 1024
+      attribute :holiday_redeeming_hours, :float
+      attribute :processed, :boolean, default: false
+
+      belongs_to :member
+      belongs_to :financial_month
+      has_many :absences,
+               ->(o){ default_where('start_at-gte': o.financial_month.begin_date.beginning_of_day, 'finish_at-lte': o.financial_month.end_date.end_of_day) },  #todo timezone consider
+               foreign_key: :member_id,
+               primary_key: :member_id
+      has_many :attendances,
+               ->(o){ default_where('attend_on-gte': o.financial_month.begin_date, 'attend_on-lte': o.financial_month.end_date, workday: true) },
+               foreign_key: :member_id,
+               primary_key: :member_id
+    end
+
+    def compute_summary
+      self.late_days = self.attendances.default_where({ 'absence_minutes-gt': 0, late_absence_id: nil, leave_absence_id: nil }, allow: [nil]).count
+      self.allowance_days = self.attendances.default_where('kind-not': 'no_meal').count
+
+      redeeming_hours = self.attendances.sum(:overtime_hours) <= 10 ? self.attendances.sum(:overtime_hours) : 10
+      leave_hours = self.absences.where(type: 'PersonLeave').sum(:hours) >= 8 ? 8 : self.absences.where(type: 'PersonLeave').sum(:hours)
+
+      self.absence_redeeming_hours = (redeeming_hours - leave_hours) > 0 ? redeeming_hours - leave_hours : 0
+
+      if redeeming_hours > 2
+        redeeming_hours -= 2
+        self.holiday_redeeming_hours = redeeming_hours
+      else
+        self.absence_redeeming_hours = redeeming_hours
+      end
+
+      self.absence_summary
+      self.processed = true
+      self
+    end
+
+    def absence_summary
+      absence_hash = self.attendances.default_where({ 'absence_minutes-gt': 0, 'absence_minutes-lte': 15, late_absence_id: nil, leave_absence_id: nil }, allow: [nil]).pluck(:absence_minutes, :attend_on).sort.map(&:reverse!).to_h
+
+      time = 0
+      absence_hash.each do |k, v|
+        time += v
+        break if time > 120
+        self.free_absence[k] = absence_hash.delete(k)
+      end
+      absence_hash.merge! self.attendances.default_where({ 'absence_minutes-gt': 15, late_absence_id: nil, leave_absence_id: nil }, allow: [nil]).pluck(:absence_minutes, :attend_on).sort.map(&:reverse!).to_h
+
+      remain = absence_redeeming_hours
+      absence_hash.each do |k, v|
+        o = (v / 30.0).ceil / 2.0
+        remain -= o
+        break if remain < 0
+        self.redeeming_absence[k] = absence_hash.delete(k)
+      end
+
+      self.redeeming_absence = {} if absence_hash.blank?
+      self.costed_absence = absence_hash
+      self.cost_absence_hours = (self.costed_absence.values.sum / 30.0).ceil / 2.0
+      self
+    end
+
+    def overtime_hash
+      return @overtime_hash if @overtime_hash
+      @overtime_hash = self.attendances.default_where('overtime_hours-gt': 0).pluck(:overtime_hours, :attend_on).sort.map(&:reverse!).to_h
+    end
+
+    def compute_summary!
+      self.compute_summary
+      self.save
+    end
+
+    class_methods do
+      def init
+        _financial_month = FinancialMonth.current_month
+
+        Attendance.distinct(:member_id).default_where('attend_on-gte': _financial_month.begin_date, 'attend_on-lte': _financial_month.end_date).pluck(:member_id).each do |member_id|
+          AttendanceStat.find_or_create_by(member_id: member_id, financial_month_id: _financial_month.id)
+        end
+      end
+
+      def compute_summary!
+        self.where(processed: false).each do |at|
+          at.compute_summary!
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,21 @@
+module Attend
+  module Model::ExtraDay
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :the_day, :date
+      attribute :name, :string
+      attribute :kind, :string, comment: 'holiday, workday'
+      attribute :scope, :string
+
+      belongs_to :organ, optional: true
+
+      enum kind: {
+        holiday: 'holiday',
+        workday: 'workday'
+      }
+    end
+
+
+  end
+end

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

@@ -0,0 +1,114 @@
+module Attend
+  module Model::FinancialMonth
+    extend ActiveSupport::Concern
+
+    included do
+      thread_mattr_accessor :current_country, instance_accessor: true
+
+      attribute :begin_date, :date
+      attribute :end_date, :date
+      attribute :working_days, :string
+      attribute :color, :string, default: '#8fdf82'
+
+      belongs_to :organ, optional: true
+
+      has_many :attendance_settings, dependent: :nullify
+
+      validate :validate_date_range, if: -> { begin_date_changed? || end_date_changed? }
+    end
+
+    def workdays
+      return @workdays if @workdays
+      origin = (begin_date..end_date).reject { |day| day.on_weekend? }
+      @workdays = origin + extra_workdays.pluck(:the_day) - holidays.pluck(:the_day)
+    end
+
+    def work_day?(date = Date.today)
+      workdays.include?(date)
+    end
+
+    def rest_days
+      return @rest_days if @rest_days
+      origin = (begin_date..end_date).select { |day| day.on_weekend? }
+      @rest_days = (origin - extra_workdays.pluck(:the_day) + holidays.pluck(:the_day)).uniq
+    end
+
+    def rest_day?(date = Date.today)
+      rest_days.include?(date)
+    end
+
+    def extra_workdays
+      ExtraDay.workday.default_where(country: FinancialMonth.current_country, 'the_day-gte': begin_date, 'the_day-lte': end_date)
+    end
+
+    def holidays
+      ExtraDay.holiday.default_where(country: FinancialMonth.current_country, 'the_day-gte': begin_date, 'the_day-lte': end_date)
+    end
+
+    def extras
+      (extra_workdays + holidays).map do |day|
+        {
+          title: day.name,
+          start: day.the_day
+        }
+      end
+    end
+
+    def month
+      self.end_date.month
+    end
+
+    def date_range
+      [begin_date, end_date].join(' ~ ')
+    end
+
+    def events
+      workdays.map do |workday|
+        {
+          title: 'Start',
+          start: workday,
+          color: self.color
+        }
+      end
+    end
+
+    def reset_attendance_settings
+      attendance_settings.each do |as|
+        as.sync_time
+      end
+    end
+
+    def validate_date_range
+      if self.end_date <= self.begin_date
+        self.errors.add :base, 'End date must later than begin date!'
+      end
+    end
+
+    def next_month
+      FinancialMonth.default_where('begin_date-gt': self.end_date).order(begin_date: :asc).first
+    end
+
+    class_methods do
+      def current_all
+        FinancialMonth.default_where('end_date-gte': Date.today)
+      end
+
+      def next_all
+        FinancialMonth.default_where('begin_date-gt': Date.today)
+      end
+
+      def current_month(day = Date.today)
+        FinancialMonth.default_where('begin_date-lte': day, 'end_date-gte': day).take
+      end
+
+      def next_month(day = Date.today)
+        self.current_month(day).next_month
+      end
+
+      def available_rest_days
+        Array(self.current_month&.rest_days) + Array(self.next_month&.rest_days)
+      end
+    end
+
+  end
+end