rails_org 0.0.1

data/app/models/org/model/job_transfer.rb

@@ -0,0 +1,108 @@
+module Org
+  module Model::JobTransfer
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :department_ancestors
+      attribute :state, :string, default: 'init'
+      attribute :transfer_on, :date
+      attribute :reason_note, :string, limit: 4096
+
+      belongs_to :member
+      belongs_to :to_office, class_name: 'Office', optional: true
+      belongs_to :to_department, class_name: 'Department', optional: true
+      belongs_to :to_job_title, class_name: 'JobTitle', optional: true
+      belongs_to :from_office, class_name: 'Office', optional: true
+      belongs_to :from_department, class_name: 'Department', optional: true
+      belongs_to :from_job_title, class_name: 'JobTitle', optional: true
+
+      enum state: {
+        init: 'init',
+        approved_sl: 'approved sl',
+        approved_om: 'approved om',
+        rejected: 'rejected'
+      }
+
+      validate :validate_select_option
+      validates :transfer_on, :reason_note, presence: true
+
+      after_initialize if: :new_record? do
+        self.from_office_id = self.member&.office_id
+        self.from_department_id = self.member&.department_id
+        self.from_job_title_id = self.member&.job_title_id
+        self.state = JobTransfer::states[:approved_sl] if self.member&.leading_department
+      end
+      after_create_commit :send_notification
+
+      acts_as_notify :default, only: []
+    end
+
+    def approve_config
+      {
+        approved_sl: member.department&.leader,
+        approved_om: member.office&.leader
+      }.with_indifferent_access
+    end
+
+    def next_operator
+      approve_config[next_state_state]
+    end
+
+    def next_state_state
+      next_state_states.first
+    end
+
+    def next_state_states
+      next_states(:state)
+    end
+
+    def do_trigger(params = {})
+      self.trigger_to state: params[:state]
+
+      self.class.transaction do
+        self.save!
+        to_notification(
+          member: self.member,
+          title: "Your Job Transfer request has been #{self.state_i18n}",
+          body: "Your Job Transfer request has been #{self.state_i18n}.",
+          link: url_helpers.my_job_transfers_url(id: self.id),
+          cc_emails: cc_emails(self.member.email)
+        )
+        if self.approved_sl?
+          send_notification
+        elsif self.approved_om? && transfer_on <= Date.today
+          member.update(department_id: self.to_department_id, office_id: self.to_office_id)
+        end
+      end
+    end
+
+    def send_notification
+      to = next_operator
+      to_notification(
+        member: to,
+        title: "#{self.member.name} has requested Job Transfer",
+        body: "#{self.member.name} has requested Job Transfer.",
+        code: self.state,
+        link: url_helpers.my_admin_job_transfers_url
+      )
+    end
+
+    def validate_select_option
+      self.errors.add :base, 'Please select the office you want to' if self.to_office.nil?
+      self.errors.add :base, 'Please select the department you want to' if self.to_department.nil?
+    end
+
+    def cc_emails(to)
+      cc = [
+        member.office.leader&.email,
+        member.department.leader&.email,
+        to_office.leader&.email,
+        to_department.leader&.email,
+        member.email
+      ]
+      cc.delete(to)
+      cc.uniq.compact
+    end
+
+  end
+end

data/app/models/org/model/member.rb

@@ -0,0 +1,142 @@
+module Org
+  module Model::Member
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :url_helpers, to: 'Rails.application.routes'
+      has_taxons :department
+
+      attribute :identity, :string, index: true
+      attribute :experience, :string
+      attribute :attendance_number, :string
+      attribute :owned, :boolean, default: false
+      attribute :organ_root_id, :integer
+      attribute :name, :string
+      attribute :number, :string
+      attribute :join_on, :date
+      attribute :enabled, :boolean, default: true
+      attribute :state, :string
+
+      belongs_to :account, -> { where(confirmed: true) }, class_name: 'Auth::Account', primary_key: :identity, foreign_key: :identity, optional: true
+      has_one :user, class_name: 'Auth::User', through: :account
+      belongs_to :profile, ->(o){ where(organ_id: o.organ_id) }, class_name: 'Profiled::Profile', primary_key: :identity, foreign_key: :identity, optional: true
+
+      belongs_to :organ, counter_cache: true, inverse_of: :members
+
+      has_many :member_departments, dependent: :delete_all
+      has_many :departments, through: :member_departments
+      has_many :job_titles, through: :member_departments
+      has_many :members, through: :member_departments, source: :members
+      accepts_nested_attributes_for :member_departments, reject_if: :all_blank, allow_destroy: true
+
+      has_many :inferior_member_departments, class_name: 'Org::MemberDepartment', foreign_key: :superior_id, primary_key: :department_ids
+      has_many :authorized_tokens, dependent: :nullify
+
+      has_one :resign
+      has_one :tutorial, ->{ order(created_at: :desc) }, dependent: :nullify
+      has_one :tutor, through: :tutorial
+      has_many :tutorials, dependent: :nullify
+      has_many :tutorings, class_name: 'Org::Tutorial', foreign_key: :tutor_id
+      has_many :tutees, through: :tutorings, source: :member
+      #has_many :job_transfers, dependent: :destroy
+
+      has_one_attached :avatar
+      has_one_attached :resume
+
+      scope :enabled, -> { where(enabled: true) }
+
+      validates :identity, uniqueness: { scope: :organ_id }
+
+      #before_save :sync_tutorials, if: -> { join_on_changed? }
+      before_save :sync_avatar_from_user, if: -> { identity_changed? }
+      #after_create :sync_member_roles, if: -> { owned? }
+    end
+
+    def admin?
+      owned?
+    end
+
+    def grade
+      member_departments.minimum(:grade)
+    end
+
+    def sync_avatar_from_user
+      if user
+        self.name ||= user.name
+        self.avatar_blob ||= user.avatar_blob
+      end
+    end
+
+    def direct_follower_ids
+      member_departments.map do |md|
+        md.direct_followers.pluck(:member_id)
+      end.flatten.uniq
+    end
+
+    def direct_followers
+      Member.where(id: direct_follower_ids)
+    end
+
+    def all_follower_ids
+      (member_departments.map do |md|
+        md.self_and_descendants.pluck(:member_id)
+      end.flatten + [self.id]).uniq
+    end
+
+    def all_followers
+      Member.where(id: all_lower_ids)
+    end
+
+    def lower_job_title_ids
+      job_titles.map(&:lower_job_title_ids).flatten.uniq
+    end
+
+    def all_lower_ids
+      MemberDepartment.where(job_title_id: lower_job_title_ids).pluck(:member_id)
+    end
+
+    def leader
+
+    end
+
+    def get_organ_grant
+      at = account.authorized_token
+      at.update member_id: self.id
+      at
+    end
+
+    def mock_organ_grant(user_id)
+      grant = self.organ_grants.find_or_create_by(user_id: user_id)
+      unless grant.verify_token?
+        grant.update_token!
+      end
+      grant
+    end
+
+    def leading_members
+      Member.where(department_id: leading_department.self_and_descendant_ids)
+    end
+
+    def leading_member_ids
+      leading_members.pluck(:id)
+    end
+
+    def leading_highest_department
+      leading_departments = self.leading_departments
+      unless leading_departments.empty?
+        leading_departments = self.leading_departments.sort_by(&:depth)
+      end
+      leading_departments.first
+    end
+
+    def avatar_url
+      url_helpers.rails_blob_url(avatar) if avatar.attachment.present?
+    end
+
+    def sync_member_roles
+      role = Roled::Role.default_where('who_types-any': 'Member', code: RailsOrg.config.super_role_code).take
+      who_roles.create(role_id: role.id) if role
+    end
+
+  end
+end

data/app/models/org/model/member_department.rb

@@ -0,0 +1,66 @@
+module Org
+  module Model::MemberDepartment
+    extend ActiveSupport::Concern
+
+    included do
+      has_taxons :department
+
+      attribute :department_root_id, :integer
+      attribute :superior_id, :integer
+      attribute :grade, :integer, default: 0
+
+      belongs_to :member
+      belongs_to :department, counter_cache: true, inverse_of: :member_departments
+      belongs_to :job_title
+      has_many :descendant_hierarchies, class_name: 'DepartmentHierarchy', foreign_key: :ancestor_id, primary_key: :department_id
+      has_many :self_and_descendants, ->(o){ default_where('grade-gt': o.grade) }, through: :descendant_hierarchies, source: :member_department
+      has_many :members, through: :self_and_descendants, source: :member
+
+      validates :department_id, uniqueness: { scope: :member_id }
+
+      before_save :sync_from_job_title, if: -> { (changes.keys & ['job_title_id', 'department_id']).present? }
+      after_save_commit :sync_department_members_count, if: -> { saved_change_to_department_id? }
+      after_save_commit :sync_role_ids
+    end
+
+    def direct_followers
+      self.class.default_where(department_id: department_id, 'grade-gt': self.grade)
+    end
+
+    def job_title_options
+      if department
+        JobTitle.where(department_root_id: department.root.id)
+      else
+        JobTitle.none
+      end
+    end
+
+    def sync_from_job_title
+      self.department_id = job_title.department_id
+      self.grade = job_title.grade
+
+      self.superior_id = department.superior_id
+      self.department_root_id = department.root.id
+    end
+
+    def sync_department_members_count
+      self.class.transaction do
+        Department.increment_counter :all_member_departments_count, department.self_and_ancestor_ids
+
+        if department_id_before_last_save
+          depart = Department.find(department_id_before_last_save)
+          Department.decrement_counter :all_member_departments_count, depart.self_and_ancestor_ids
+        end
+      end
+    end
+
+    def sync_role_ids
+      r_ids = self.member.role_ids
+      if job_title
+        r_ids = r_ids | self.job_title.role_ids
+      end
+      self.member.role_ids = r_ids
+    end
+
+  end
+end

data/app/models/org/model/organ.rb

@@ -0,0 +1,62 @@
+module Org
+  module Model::Organ
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :name, :string
+      attribute :name_short, :string
+      attribute :address, :string
+      attribute :members_count, :integer, default: 0
+      attribute :official, :boolean, default: false, comment: '是否官方'
+      attribute :joinable, :boolean, default: false, comment: '是否可搜索并加入'
+      attribute :domain, :string
+
+      has_taxons :area
+      belongs_to :area, class_name: 'Profiled::Area', optional: true
+
+      has_one :organ_domain, -> { where(default: true) }, inverse_of: :organ
+      has_many :supports, -> { where(department_id: nil) }, dependent: :destroy
+      has_many :departments, dependent: :destroy
+      has_many :members, dependent: :destroy
+      has_many :super_job_titles, dependent: :destroy
+      has_many :organ_domains, dependent: :destroy
+      accepts_nested_attributes_for :members
+
+      has_one_attached :logo
+
+      scope :official, -> { where(official: true) }
+
+      validates :name, presence: true
+    end
+
+    def host
+      if domain.blank?
+        init_organ_domain
+        save
+      end
+      # todo deal with port
+      ActionDispatch::Http::URL.url_for(
+        host: domain,
+        protocol: Rails.application.routes.default_url_options[:protocol]
+      )
+    end
+
+    def url_options
+      od = organ_domain || organ_domains.take || build_organ_domain
+      od.as_json(only: [:host, :port])
+    end
+
+    def init_organ_domain
+      organ_domain || build_organ_domain
+    end
+
+    def domains
+      organ_domains.pluck(:identifier)
+    end
+
+    def admin?
+      Array(cached_role_ids).compact.blank? && official?
+    end
+
+  end
+end

data/app/models/org/model/organ_domain.rb

@@ -0,0 +1,44 @@
+module Org
+  module Model::OrganDomain
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :subdomain, :string
+      attribute :domain, :string, default: Rails.application.routes.default_url_options[:host]
+      attribute :port, :string, default: Rails.application.routes.default_url_options[:port]
+      attribute :host, :string
+      attribute :identifier, :string, index: true
+      attribute :appid, :string
+      attribute :default, :boolean, default: false
+
+      belongs_to :organ
+      belongs_to :wechat_app, class_name: 'Wechat::App', foreign_key: :appid, primary_key: :appid, optional: true
+
+      validates :identifier, uniqueness: true
+
+      after_initialize :init_subdomain, if: -> { new_record? && subdomain.nil? }
+      before_validation :compute_identifier, if: -> { (changes.keys & ['domain', 'subdomain', 'port', 'host']).present? }
+      after_update :set_default, if: -> { default? && saved_change_to_default? }
+      after_save :sync_domain_to_organ, if: -> { saved_change_to_identifier? || (default? && saved_change_to_default?) }
+    end
+
+    def set_default
+      self.class.where.not(id: self.id).where(organ_id: self.organ_id).update_all(default: false)
+    end
+
+    def sync_domain_to_organ
+      organ.update domain: identifier
+    end
+
+    def compute_identifier
+      self.host = [subdomain.presence, domain].compact.join('.')
+      self.identifier = [host, port.presence].compact.join(':')
+    end
+
+    def init_subdomain
+      self.subdomain = ['org', organ_id].join('-')
+      compute_identifier
+    end
+
+  end
+end

data/app/models/org/model/organ_handle.rb

@@ -0,0 +1,15 @@
+module Org
+  module Model::OrganHandle
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :record_class, :string
+      attribute :record_column, :string
+      attribute :name, :string
+      attribute :description, :string
+
+      has_many :department_grants, dependent: :destroy
+    end
+
+  end
+end

data/app/models/org/model/resign.rb

@@ -0,0 +1,66 @@
+module Org
+  module Model::Resign
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :leave_on, :date
+      attribute :reason_note, :string
+      attribute :handover_note, :string
+      attribute :comment, :string
+
+      validates :leave_on, :reason_note, presence: true
+      validate :validate_resign_reasons
+
+      belongs_to :member
+      has_many :resign_references
+      has_many :resign_reasons, through: :resign_references
+
+      enum state: {
+        init: 'init',
+        approved: 'approved',
+        rejected: 'rejected'
+      }, _default: 'init'
+
+      after_create_commit :send_notification
+
+      acts_as_notify only: [:reason_note, :leave_on]
+    end
+
+    def do_trigger(params = {})
+      self.trigger_to(params.slice(:state))
+
+      self.class.transaction do
+        self.save!
+        to_notification(
+          sender: self.member.office.leader,
+          member: self.member,
+          title: "Your resignation request has been #{self.state_i18n}.",
+          body: "Your resignation request has been #{self.state_i18n}.",
+          link: url_helpers.my_resign_url,
+          cc_emails: [
+            self.member.office.leader.email
+          ],
+        )
+      end
+    end
+
+    def send_notification
+      to_notification(
+        sender: self.member,
+        member: self.member.office.leader,
+        body: "#{self.member.name} has requested resignation",
+        title: "#{self.member.name} has requested resignation",
+        cc_emails: [
+          self.member.email
+        ],
+        link: url_helpers.admin_resign_url(id: self.id),
+        verbose: true
+      )
+    end
+
+    def validate_resign_reasons
+      self.errors.add :base, 'Please select one reason at least' if self.resign_reasons.empty?
+    end
+
+  end
+end